LCOV - code coverage report
Current view: top level - usr/include/c++/9/bits - list.tcc (source / functions) Hit Total Coverage
Test: ROSE Lines: 39 206 18.9 %
Date: 2022-12-08 13:48:47 Functions: 20 97 20.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // List implementation (out of line) -*- C++ -*-
       2             : 
       3             : // Copyright (C) 2001-2019 Free Software Foundation, Inc.
       4             : //
       5             : // This file is part of the GNU ISO C++ Library.  This library is free
       6             : // software; you can redistribute it and/or modify it under the
       7             : // terms of the GNU General Public License as published by the
       8             : // Free Software Foundation; either version 3, or (at your option)
       9             : // any later version.
      10             : 
      11             : // This library is distributed in the hope that it will be useful,
      12             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : // GNU General Public License for more details.
      15             : 
      16             : // Under Section 7 of GPL version 3, you are granted additional
      17             : // permissions described in the GCC Runtime Library Exception, version
      18             : // 3.1, as published by the Free Software Foundation.
      19             : 
      20             : // You should have received a copy of the GNU General Public License and
      21             : // a copy of the GCC Runtime Library Exception along with this program;
      22             : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
      23             : // <http://www.gnu.org/licenses/>.
      24             : 
      25             : /*
      26             :  *
      27             :  * Copyright (c) 1994
      28             :  * Hewlett-Packard Company
      29             :  *
      30             :  * Permission to use, copy, modify, distribute and sell this software
      31             :  * and its documentation for any purpose is hereby granted without fee,
      32             :  * provided that the above copyright notice appear in all copies and
      33             :  * that both that copyright notice and this permission notice appear
      34             :  * in supporting documentation.  Hewlett-Packard Company makes no
      35             :  * representations about the suitability of this software for any
      36             :  * purpose.  It is provided "as is" without express or implied warranty.
      37             :  *
      38             :  *
      39             :  * Copyright (c) 1996,1997
      40             :  * Silicon Graphics Computer Systems, Inc.
      41             :  *
      42             :  * Permission to use, copy, modify, distribute and sell this software
      43             :  * and its documentation for any purpose is hereby granted without fee,
      44             :  * provided that the above copyright notice appear in all copies and
      45             :  * that both that copyright notice and this permission notice appear
      46             :  * in supporting documentation.  Silicon Graphics makes no
      47             :  * representations about the suitability of this software for any
      48             :  * purpose.  It is provided "as is" without express or implied warranty.
      49             :  */
      50             : 
      51             : /** @file bits/list.tcc
      52             :  *  This is an internal header file, included by other library headers.
      53             :  *  Do not attempt to use it directly. @headername{list}
      54             :  */
      55             : 
      56             : #ifndef _LIST_TCC
      57             : #define _LIST_TCC 1
      58             : 
      59             : namespace std _GLIBCXX_VISIBILITY(default)
      60             : {
      61             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      62             : _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
      63             : 
      64             :   template<typename _Tp, typename _Alloc>
      65             :     void
      66    18232673 :     _List_base<_Tp, _Alloc>::
      67             :     _M_clear() _GLIBCXX_NOEXCEPT
      68             :     {
      69             :       typedef _List_node<_Tp>  _Node;
      70    18232673 :       __detail::_List_node_base* __cur = _M_impl._M_node._M_next;
      71    55313528 :       while (__cur != &_M_impl._M_node)
      72             :         {
      73    37080749 :           _Node* __tmp = static_cast<_Node*>(__cur);
      74    37080749 :           __cur = __tmp->_M_next;
      75    37080749 :           _Tp* __val = __tmp->_M_valptr();
      76             : #if __cplusplus >= 201103L
      77    37080749 :           _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val);
      78             : #else
      79             :           _Tp_alloc_type(_M_get_Node_allocator()).destroy(__val);
      80             : #endif
      81    55314142 :           _M_put_node(__tmp);
      82             :         }
      83        5061 :     }
      84             : 
      85             : #if __cplusplus >= 201103L
      86             :   template<typename _Tp, typename _Alloc>
      87             :     template<typename... _Args>
      88             :       typename list<_Tp, _Alloc>::iterator
      89           0 :       list<_Tp, _Alloc>::
      90             :       emplace(const_iterator __position, _Args&&... __args)
      91             :       {
      92           0 :         _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
      93           0 :         __tmp->_M_hook(__position._M_const_cast()._M_node);
      94           0 :         this->_M_inc_size(1);
      95           0 :         return iterator(__tmp);
      96             :       }
      97             : #endif
      98             : 
      99             :   template<typename _Tp, typename _Alloc>
     100             :     typename list<_Tp, _Alloc>::iterator
     101           0 :     list<_Tp, _Alloc>::
     102             : #if __cplusplus >= 201103L
     103             :     insert(const_iterator __position, const value_type& __x)
     104             : #else
     105             :     insert(iterator __position, const value_type& __x)
     106             : #endif
     107             :     {
     108           0 :       _Node* __tmp = _M_create_node(__x);
     109           0 :       __tmp->_M_hook(__position._M_const_cast()._M_node);
     110           0 :       this->_M_inc_size(1);
     111           0 :       return iterator(__tmp);
     112             :     }
     113             : 
     114             : #if __cplusplus >= 201103L
     115             :   template<typename _Tp, typename _Alloc>
     116             :     typename list<_Tp, _Alloc>::iterator
     117           0 :     list<_Tp, _Alloc>::
     118             :     insert(const_iterator __position, size_type __n, const value_type& __x)
     119             :     {
     120           0 :       if (__n)
     121             :         {
     122           0 :           list __tmp(__n, __x, get_allocator());
     123           0 :           iterator __it = __tmp.begin();
     124           0 :           splice(__position, __tmp);
     125           0 :           return __it;
     126             :         }
     127           0 :       return __position._M_const_cast();
     128             :     }
     129             : 
     130             :   template<typename _Tp, typename _Alloc>
     131             :     template<typename _InputIterator, typename>
     132             :       typename list<_Tp, _Alloc>::iterator
     133         141 :       list<_Tp, _Alloc>::
     134             :       insert(const_iterator __position, _InputIterator __first,
     135             :              _InputIterator __last)
     136             :       {
     137         141 :         list __tmp(__first, __last, get_allocator());
     138         141 :         if (!__tmp.empty())
     139             :           {
     140         141 :             iterator __it = __tmp.begin();
     141         141 :             splice(__position, __tmp);
     142         141 :             return __it;
     143             :           }
     144           0 :         return __position._M_const_cast();
     145             :       }
     146             : #endif
     147             : 
     148             :   template<typename _Tp, typename _Alloc>
     149             :     typename list<_Tp, _Alloc>::iterator
     150           0 :     list<_Tp, _Alloc>::
     151             : #if __cplusplus >= 201103L
     152             :     erase(const_iterator __position) noexcept
     153             : #else
     154             :     erase(iterator __position)
     155             : #endif
     156             :     {
     157           0 :       iterator __ret = iterator(__position._M_node->_M_next);
     158           0 :       _M_erase(__position._M_const_cast());
     159           0 :       return __ret;
     160             :     }
     161             : 
     162             :   // Return a const_iterator indicating the position to start inserting or
     163             :   // erasing elements (depending whether the list is growing or shrinking),
     164             :   // and set __new_size to the number of new elements that must be appended.
     165             :   // Equivalent to the following, but performed optimally:
     166             :   // if (__new_size < size()) {
     167             :   //   __new_size = 0;
     168             :   //   return std::next(begin(), __new_size);
     169             :   // } else {
     170             :   //   __newsize -= size();
     171             :   //   return end();
     172             :   // }
     173             :   template<typename _Tp, typename _Alloc>
     174             :     typename list<_Tp, _Alloc>::const_iterator
     175           0 :     list<_Tp, _Alloc>::
     176             :     _M_resize_pos(size_type& __new_size) const
     177             :     {
     178           0 :       const_iterator __i;
     179             : #if _GLIBCXX_USE_CXX11_ABI
     180           0 :       const size_type __len = size();
     181           0 :       if (__new_size < __len)
     182             :         {
     183           0 :           if (__new_size <= __len / 2)
     184             :             {
     185           0 :               __i = begin();
     186           0 :               std::advance(__i, __new_size);
     187             :             }
     188             :           else
     189             :             {
     190           0 :               __i = end();
     191           0 :               ptrdiff_t __num_erase = __len - __new_size;
     192           0 :               std::advance(__i, -__num_erase);
     193             :             }
     194           0 :           __new_size = 0;
     195           0 :           return __i;
     196             :         }
     197             :       else
     198           0 :         __i = end();
     199             : #else
     200             :       size_type __len = 0;
     201             :       for (__i = begin(); __i != end() && __len < __new_size; ++__i, ++__len)
     202             :         ;
     203             : #endif
     204           0 :       __new_size -= __len;
     205           0 :       return __i;
     206             :     }
     207             : 
     208             : #if __cplusplus >= 201103L
     209             :   template<typename _Tp, typename _Alloc>
     210             :     void
     211           0 :     list<_Tp, _Alloc>::
     212             :     _M_default_append(size_type __n)
     213             :     {
     214           0 :       size_type __i = 0;
     215             :       __try
     216             :         {
     217           0 :           for (; __i < __n; ++__i)
     218           0 :             emplace_back();
     219             :         }
     220           0 :       __catch(...)
     221             :         {
     222           0 :           for (; __i; --__i)
     223           0 :             pop_back();
     224           0 :           __throw_exception_again;
     225             :         }
     226           0 :     }
     227             : 
     228             :   template<typename _Tp, typename _Alloc>
     229             :     void
     230           0 :     list<_Tp, _Alloc>::
     231             :     resize(size_type __new_size)
     232             :     {
     233           0 :       const_iterator __i = _M_resize_pos(__new_size);
     234           0 :       if (__new_size)
     235           0 :         _M_default_append(__new_size);
     236             :       else
     237           0 :         erase(__i, end());
     238           0 :     }
     239             : 
     240             :   template<typename _Tp, typename _Alloc>
     241             :     void
     242           0 :     list<_Tp, _Alloc>::
     243             :     resize(size_type __new_size, const value_type& __x)
     244             :     {
     245           0 :       const_iterator __i = _M_resize_pos(__new_size);
     246           0 :       if (__new_size)
     247           0 :         insert(end(), __new_size, __x);
     248             :       else
     249           0 :         erase(__i, end());
     250           0 :     }
     251             : #else
     252             :   template<typename _Tp, typename _Alloc>
     253             :     void
     254             :     list<_Tp, _Alloc>::
     255             :     resize(size_type __new_size, value_type __x)
     256             :     {
     257             :       const_iterator __i = _M_resize_pos(__new_size);
     258             :       if (__new_size)
     259             :         insert(end(), __new_size, __x);
     260             :       else
     261             :         erase(__i._M_const_cast(), end());
     262             :     }
     263             : #endif
     264             : 
     265             :   template<typename _Tp, typename _Alloc>
     266             :     list<_Tp, _Alloc>&
     267        9331 :     list<_Tp, _Alloc>::
     268             :     operator=(const list& __x)
     269             :     {
     270        9331 :       if (this != std::__addressof(__x))
     271             :         {
     272             : #if __cplusplus >= 201103L
     273             :           if (_Node_alloc_traits::_S_propagate_on_copy_assign())
     274             :             {
     275             :               auto& __this_alloc = this->_M_get_Node_allocator();
     276             :               auto& __that_alloc = __x._M_get_Node_allocator();
     277             :               if (!_Node_alloc_traits::_S_always_equal()
     278             :                   && __this_alloc != __that_alloc)
     279             :                 {
     280             :                   // replacement allocator cannot free existing storage
     281             :                   clear();
     282             :                 }
     283             :               std::__alloc_on_copy(__this_alloc, __that_alloc);
     284             :             }
     285             : #endif
     286        9331 :           _M_assign_dispatch(__x.begin(), __x.end(), __false_type());
     287             :         }
     288           0 :       return *this;
     289             :     }
     290             : 
     291             :   template<typename _Tp, typename _Alloc>
     292             :     void
     293           0 :     list<_Tp, _Alloc>::
     294             :     _M_fill_assign(size_type __n, const value_type& __val)
     295             :     {
     296           0 :       iterator __i = begin();
     297           0 :       for (; __i != end() && __n > 0; ++__i, --__n)
     298           0 :         *__i = __val;
     299           0 :       if (__n > 0)
     300           0 :         insert(end(), __n, __val);
     301             :       else
     302           0 :         erase(__i, end());
     303           0 :     }
     304             : 
     305             :   template<typename _Tp, typename _Alloc>
     306             :     template <typename _InputIterator>
     307             :       void
     308        9331 :       list<_Tp, _Alloc>::
     309             :       _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
     310             :                          __false_type)
     311             :       {
     312        9331 :         iterator __first1 = begin();
     313        9331 :         iterator __last1 = end();
     314           0 :         for (; __first1 != __last1 && __first2 != __last2;
     315        9331 :              ++__first1, (void)++__first2)
     316           0 :           *__first1 = *__first2;
     317        9331 :         if (__first2 == __last2)
     318        9190 :           erase(__first1, __last1);
     319             :         else
     320         141 :           insert(__last1, __first2, __last2);
     321        9331 :       }
     322             : 
     323             : #if __cplusplus > 201703L
     324             : # define _GLIBCXX20_ONLY(__expr) __expr
     325             : #else
     326             : # define _GLIBCXX20_ONLY(__expr)
     327             : #endif
     328             : 
     329             :   template<typename _Tp, typename _Alloc>
     330             :     typename list<_Tp, _Alloc>::__remove_return_type
     331          62 :     list<_Tp, _Alloc>::
     332             :     remove(const value_type& __value)
     333             :     {
     334          62 :       size_type __removed __attribute__((__unused__)) = 0;
     335          62 :       iterator __first = begin();
     336          62 :       iterator __last = end();
     337          62 :       iterator __extra = __last;
     338         262 :       while (__first != __last)
     339             :         {
     340         200 :           iterator __next = __first;
     341         200 :           ++__next;
     342         200 :           if (*__first == __value)
     343             :             {
     344             :               // _GLIBCXX_RESOLVE_LIB_DEFECTS
     345             :               // 526. Is it undefined if a function in the standard changes
     346             :               // in parameters?
     347          62 :               if (std::__addressof(*__first) != std::__addressof(__value))
     348             :                 {
     349          62 :                   _M_erase(__first);
     350             :                   _GLIBCXX20_ONLY( __removed++ );
     351             :                 }
     352             :               else
     353             :                 __extra = __first;
     354             :             }
     355             :           __first = __next;
     356             :         }
     357          62 :       if (__extra != __last)
     358             :         {
     359           0 :           _M_erase(__extra);
     360             :           _GLIBCXX20_ONLY( __removed++ );
     361             :         }
     362          62 :       return _GLIBCXX20_ONLY( __removed );
     363             :     }
     364             : 
     365             :   template<typename _Tp, typename _Alloc>
     366             :     typename list<_Tp, _Alloc>::__remove_return_type
     367           0 :     list<_Tp, _Alloc>::
     368             :     unique()
     369             :     {
     370           0 :       iterator __first = begin();
     371           0 :       iterator __last = end();
     372           0 :       if (__first == __last)
     373             :         return _GLIBCXX20_ONLY( 0 );
     374           0 :       size_type __removed __attribute__((__unused__)) = 0;
     375             :       iterator __next = __first;
     376           0 :       while (++__next != __last)
     377             :         {
     378           0 :           if (*__first == *__next)
     379             :             {
     380           0 :               _M_erase(__next);
     381             :               _GLIBCXX20_ONLY( __removed++ );
     382             :             }
     383             :           else
     384             :             __first = __next;
     385             :           __next = __first;
     386             :         }
     387             :       return _GLIBCXX20_ONLY( __removed );
     388             :     }
     389             : 
     390             :   template<typename _Tp, typename _Alloc>
     391             :     void
     392           0 :     list<_Tp, _Alloc>::
     393             : #if __cplusplus >= 201103L
     394             :     merge(list&& __x)
     395             : #else
     396             :     merge(list& __x)
     397             : #endif
     398             :     {
     399             :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     400             :       // 300. list::merge() specification incomplete
     401           0 :       if (this != std::__addressof(__x))
     402             :         {
     403           0 :           _M_check_equal_allocators(__x);
     404             : 
     405           0 :           iterator __first1 = begin();
     406           0 :           iterator __last1 = end();
     407           0 :           iterator __first2 = __x.begin();
     408           0 :           iterator __last2 = __x.end();
     409           0 :           const size_t __orig_size = __x.size();
     410             :           __try {
     411           0 :             while (__first1 != __last1 && __first2 != __last2)
     412           0 :               if (*__first2 < *__first1)
     413             :                 {
     414           0 :                   iterator __next = __first2;
     415           0 :                   _M_transfer(__first1, __first2, ++__next);
     416           0 :                   __first2 = __next;
     417             :                 }
     418             :               else
     419           0 :                 ++__first1;
     420           0 :             if (__first2 != __last2)
     421           0 :               _M_transfer(__last1, __first2, __last2);
     422             : 
     423           0 :             this->_M_inc_size(__x._M_get_size());
     424           0 :             __x._M_set_size(0);
     425             :           }
     426             :           __catch(...)
     427             :             {
     428             :               const size_t __dist = std::distance(__first2, __last2);
     429             :               this->_M_inc_size(__orig_size - __dist);
     430             :               __x._M_set_size(__dist);
     431             :               __throw_exception_again;
     432             :             }
     433             :         }
     434           0 :     }
     435             : 
     436             :   template<typename _Tp, typename _Alloc>
     437             :     template <typename _StrictWeakOrdering>
     438             :       void
     439           0 :       list<_Tp, _Alloc>::
     440             : #if __cplusplus >= 201103L
     441             :       merge(list&& __x, _StrictWeakOrdering __comp)
     442             : #else
     443             :       merge(list& __x, _StrictWeakOrdering __comp)
     444             : #endif
     445             :       {
     446             :         // _GLIBCXX_RESOLVE_LIB_DEFECTS
     447             :         // 300. list::merge() specification incomplete
     448           0 :         if (this != std::__addressof(__x))
     449             :           {
     450           0 :             _M_check_equal_allocators(__x);
     451             : 
     452           0 :             iterator __first1 = begin();
     453           0 :             iterator __last1 = end();
     454           0 :             iterator __first2 = __x.begin();
     455           0 :             iterator __last2 = __x.end();
     456           0 :             const size_t __orig_size = __x.size();
     457             :             __try
     458             :               {
     459           0 :                 while (__first1 != __last1 && __first2 != __last2)
     460           0 :                   if (__comp(*__first2, *__first1))
     461             :                     {
     462           0 :                       iterator __next = __first2;
     463           0 :                       _M_transfer(__first1, __first2, ++__next);
     464           0 :                       __first2 = __next;
     465             :                     }
     466             :                   else
     467           0 :                     ++__first1;
     468           0 :                 if (__first2 != __last2)
     469           0 :                   _M_transfer(__last1, __first2, __last2);
     470             : 
     471           0 :                 this->_M_inc_size(__x._M_get_size());
     472           0 :                 __x._M_set_size(0);
     473             :               }
     474           0 :             __catch(...)
     475             :               {
     476           0 :                 const size_t __dist = std::distance(__first2, __last2);
     477           0 :                 this->_M_inc_size(__orig_size - __dist);
     478           0 :                 __x._M_set_size(__dist);
     479           0 :                 __throw_exception_again;
     480             :               }
     481             :           }
     482           0 :       }
     483             : 
     484             :   template<typename _Tp, typename _Alloc>
     485             :     void
     486           0 :     list<_Tp, _Alloc>::
     487             :     sort()
     488             :     {
     489             :       // Do nothing if the list has length 0 or 1.
     490           0 :       if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
     491           0 :           && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
     492             :       {
     493           0 :         list __carry;
     494           0 :         list __tmp[64];
     495             :         list * __fill = __tmp;
     496             :         list * __counter;
     497             :         __try
     498             :           {
     499             :             do
     500             :               {
     501           0 :                 __carry.splice(__carry.begin(), *this, begin());
     502             : 
     503           0 :                 for(__counter = __tmp;
     504           0 :                     __counter != __fill && !__counter->empty();
     505             :                     ++__counter)
     506             :                   {
     507           0 :                     __counter->merge(__carry);
     508           0 :                     __carry.swap(*__counter);
     509             :                   }
     510           0 :                 __carry.swap(*__counter);
     511           0 :                 if (__counter == __fill)
     512           0 :                   ++__fill;
     513             :               }
     514           0 :             while ( !empty() );
     515             : 
     516           0 :             for (__counter = __tmp + 1; __counter != __fill; ++__counter)
     517           0 :               __counter->merge(*(__counter - 1));
     518           0 :             swap( *(__fill - 1) );
     519             :           }
     520           0 :         __catch(...)
     521             :           {
     522           0 :             this->splice(this->end(), __carry);
     523           0 :             for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
     524           0 :               this->splice(this->end(), __tmp[__i]);
     525           0 :             __throw_exception_again;
     526             :           }
     527             :       }
     528           0 :     }
     529             : 
     530             :   template<typename _Tp, typename _Alloc>
     531             :     template <typename _Predicate>
     532             :       typename list<_Tp, _Alloc>::__remove_return_type
     533             :       list<_Tp, _Alloc>::
     534             :       remove_if(_Predicate __pred)
     535             :       {
     536             :         size_type __removed __attribute__((__unused__)) = 0;
     537             :         iterator __first = begin();
     538             :         iterator __last = end();
     539             :         while (__first != __last)
     540             :           {
     541             :             iterator __next = __first;
     542             :             ++__next;
     543             :             if (__pred(*__first))
     544             :               {
     545             :                 _M_erase(__first);
     546             :                 _GLIBCXX20_ONLY( __removed++ );
     547             :               }
     548             :             __first = __next;
     549             :           }
     550             :         return _GLIBCXX20_ONLY( __removed );
     551             :       }
     552             : 
     553             :   template<typename _Tp, typename _Alloc>
     554             :     template <typename _BinaryPredicate>
     555             :       typename list<_Tp, _Alloc>::__remove_return_type
     556             :       list<_Tp, _Alloc>::
     557             :       unique(_BinaryPredicate __binary_pred)
     558             :       {
     559             :         iterator __first = begin();
     560             :         iterator __last = end();
     561             :         if (__first == __last)
     562             :           return _GLIBCXX20_ONLY(0);
     563             :         size_type __removed __attribute__((__unused__)) = 0;
     564             :         iterator __next = __first;
     565             :         while (++__next != __last)
     566             :           {
     567             :             if (__binary_pred(*__first, *__next))
     568             :               {
     569             :                 _M_erase(__next);
     570             :                 _GLIBCXX20_ONLY( __removed++ );
     571             :               }
     572             :             else
     573             :               __first = __next;
     574             :             __next = __first;
     575             :           }
     576             :         return _GLIBCXX20_ONLY( __removed );
     577             :       }
     578             : 
     579             : #undef _GLIBCXX20_ONLY
     580             : 
     581             :   template<typename _Tp, typename _Alloc>
     582             :     template <typename _StrictWeakOrdering>
     583             :       void
     584           0 :       list<_Tp, _Alloc>::
     585             :       sort(_StrictWeakOrdering __comp)
     586             :       {
     587             :         // Do nothing if the list has length 0 or 1.
     588           0 :         if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
     589           0 :             && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
     590             :           {
     591           0 :             list __carry;
     592           0 :             list __tmp[64];
     593             :             list * __fill = __tmp;
     594             :             list * __counter;
     595             :             __try
     596             :               {
     597             :                 do
     598             :                   {
     599           0 :                     __carry.splice(__carry.begin(), *this, begin());
     600             : 
     601           0 :                     for(__counter = __tmp;
     602           0 :                         __counter != __fill && !__counter->empty();
     603             :                         ++__counter)
     604             :                       {
     605           0 :                         __counter->merge(__carry, __comp);
     606           0 :                         __carry.swap(*__counter);
     607             :                       }
     608           0 :                     __carry.swap(*__counter);
     609           0 :                     if (__counter == __fill)
     610           0 :                       ++__fill;
     611             :                   }
     612           0 :                 while ( !empty() );
     613             : 
     614           0 :                 for (__counter = __tmp + 1; __counter != __fill; ++__counter)
     615           0 :                   __counter->merge(*(__counter - 1), __comp);
     616           0 :                 swap(*(__fill - 1));
     617             :               }
     618           0 :             __catch(...)
     619             :               {
     620           0 :                 this->splice(this->end(), __carry);
     621           0 :                 for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
     622           0 :                   this->splice(this->end(), __tmp[__i]);
     623           0 :                 __throw_exception_again;
     624             :               }
     625             :           }
     626           0 :       }
     627             : 
     628             : _GLIBCXX_END_NAMESPACE_CONTAINER
     629             : _GLIBCXX_END_NAMESPACE_VERSION
     630             : } // namespace std
     631             : 
     632             : #endif /* _LIST_TCC */
     633             : 

Generated by: LCOV version 1.14