LCOV - code coverage report
Current view: top level - usr/include/c++/4.9/bits - basic_string.tcc (source / functions) Hit Total Coverage
Test: coverage.info Lines: 11 13 84.6 %
Date: 2016-09-12 13:07:23 Functions: 2 2 100.0 %

          Line data    Source code
       1             : // Components for manipulating sequences of characters -*- C++ -*-
       2             : 
       3             : // Copyright (C) 1997-2014 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             : /** @file bits/basic_string.tcc
      26             :  *  This is an internal header file, included by other library headers.
      27             :  *  Do not attempt to use it directly. @headername{string}
      28             :  */
      29             : 
      30             : //
      31             : // ISO C++ 14882: 21  Strings library
      32             : //
      33             : 
      34             : // Written by Jason Merrill based upon the specification by Takanori Adachi
      35             : // in ANSI X3J16/94-0013R2.  Rewritten by Nathan Myers to ISO-14882.
      36             : 
      37             : #ifndef _BASIC_STRING_TCC
      38             : #define _BASIC_STRING_TCC 1
      39             : 
      40             : #pragma GCC system_header
      41             : 
      42             : #include <bits/cxxabi_forced.h>
      43             : 
      44             : namespace std _GLIBCXX_VISIBILITY(default)
      45             : {
      46             : _GLIBCXX_BEGIN_NAMESPACE_VERSION
      47             : 
      48             :   template<typename _CharT, typename _Traits, typename _Alloc>
      49             :     const typename basic_string<_CharT, _Traits, _Alloc>::size_type
      50             :     basic_string<_CharT, _Traits, _Alloc>::
      51             :     _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
      52             : 
      53             :   template<typename _CharT, typename _Traits, typename _Alloc>
      54             :     const _CharT
      55             :     basic_string<_CharT, _Traits, _Alloc>::
      56             :     _Rep::_S_terminal = _CharT();
      57             : 
      58             :   template<typename _CharT, typename _Traits, typename _Alloc>
      59             :     const typename basic_string<_CharT, _Traits, _Alloc>::size_type
      60             :     basic_string<_CharT, _Traits, _Alloc>::npos;
      61             : 
      62             :   // Linker sets _S_empty_rep_storage to all 0s (one reference, empty string)
      63             :   // at static init time (before static ctors are run).
      64             :   template<typename _CharT, typename _Traits, typename _Alloc>
      65             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
      66             :     basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
      67             :     (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
      68             :       sizeof(size_type)];
      69             : 
      70             :   // NB: This is the special case for Input Iterators, used in
      71             :   // istreambuf_iterators, etc.
      72             :   // Input Iterators have a cost structure very different from
      73             :   // pointers, calling for a different coding style.
      74             :   template<typename _CharT, typename _Traits, typename _Alloc>
      75             :     template<typename _InIterator>
      76             :       _CharT*
      77             :       basic_string<_CharT, _Traits, _Alloc>::
      78             :       _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
      79             :                    input_iterator_tag)
      80             :       {
      81             : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
      82             :         if (__beg == __end && __a == _Alloc())
      83             :           return _S_empty_rep()._M_refdata();
      84             : #endif
      85             :         // Avoid reallocation for common case.
      86             :         _CharT __buf[128];
      87             :         size_type __len = 0;
      88             :         while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
      89             :           {
      90             :             __buf[__len++] = *__beg;
      91             :             ++__beg;
      92             :           }
      93             :         _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
      94             :         _M_copy(__r->_M_refdata(), __buf, __len);
      95             :         __try
      96             :           {
      97             :             while (__beg != __end)
      98             :               {
      99             :                 if (__len == __r->_M_capacity)
     100             :                   {
     101             :                     // Allocate more space.
     102             :                     _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
     103             :                     _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
     104             :                     __r->_M_destroy(__a);
     105             :                     __r = __another;
     106             :                   }
     107             :                 __r->_M_refdata()[__len++] = *__beg;
     108             :                 ++__beg;
     109             :               }
     110             :           }
     111             :         __catch(...)
     112             :           {
     113             :             __r->_M_destroy(__a);
     114             :             __throw_exception_again;
     115             :           }
     116             :         __r->_M_set_length_and_sharable(__len);
     117             :         return __r->_M_refdata();
     118             :       }
     119             : 
     120             :   template<typename _CharT, typename _Traits, typename _Alloc>
     121             :     template <typename _InIterator>
     122             :       _CharT*
     123          64 :       basic_string<_CharT, _Traits, _Alloc>::
     124             :       _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
     125             :                    forward_iterator_tag)
     126             :       {
     127             : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
     128          64 :         if (__beg == __end && __a == _Alloc())
     129           0 :           return _S_empty_rep()._M_refdata();
     130             : #endif
     131             :         // NB: Not required, but considered best practice.
     132          64 :         if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
     133           0 :           __throw_logic_error(__N("basic_string::_S_construct null not valid"));
     134             : 
     135             :         const size_type __dnew = static_cast<size_type>(std::distance(__beg,
     136          64 :                                                                       __end));
     137             :         // Check for out_of_range and length_error exceptions.
     138          64 :         _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
     139             :         __try
     140          64 :           { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
     141             :         __catch(...)
     142             :           {
     143             :             __r->_M_destroy(__a);
     144             :             __throw_exception_again;
     145             :           }
     146          64 :         __r->_M_set_length_and_sharable(__dnew);
     147          64 :         return __r->_M_refdata();
     148             :       }
     149             : 
     150             :   template<typename _CharT, typename _Traits, typename _Alloc>
     151             :     _CharT*
     152             :     basic_string<_CharT, _Traits, _Alloc>::
     153             :     _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
     154             :     {
     155             : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
     156             :       if (__n == 0 && __a == _Alloc())
     157             :         return _S_empty_rep()._M_refdata();
     158             : #endif
     159             :       // Check for out_of_range and length_error exceptions.
     160             :       _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
     161             :       if (__n)
     162             :         _M_assign(__r->_M_refdata(), __n, __c);
     163             : 
     164             :       __r->_M_set_length_and_sharable(__n);
     165             :       return __r->_M_refdata();
     166             :     }
     167             : 
     168             :   template<typename _CharT, typename _Traits, typename _Alloc>
     169             :     basic_string<_CharT, _Traits, _Alloc>::
     170             :     basic_string(const basic_string& __str)
     171             :     : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
     172             :                                           __str.get_allocator()),
     173             :                   __str.get_allocator())
     174             :     { }
     175             : 
     176             :   template<typename _CharT, typename _Traits, typename _Alloc>
     177             :     basic_string<_CharT, _Traits, _Alloc>::
     178             :     basic_string(const _Alloc& __a)
     179             :     : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
     180             :     { }
     181             : 
     182             :   template<typename _CharT, typename _Traits, typename _Alloc>
     183             :     basic_string<_CharT, _Traits, _Alloc>::
     184             :     basic_string(const basic_string& __str, size_type __pos, size_type __n)
     185             :     : _M_dataplus(_S_construct(__str._M_data()
     186             :                                + __str._M_check(__pos,
     187             :                                                 "basic_string::basic_string"),
     188             :                                __str._M_data() + __str._M_limit(__pos, __n)
     189             :                                + __pos, _Alloc()), _Alloc())
     190             :     { }
     191             : 
     192             :   template<typename _CharT, typename _Traits, typename _Alloc>
     193             :     basic_string<_CharT, _Traits, _Alloc>::
     194             :     basic_string(const basic_string& __str, size_type __pos,
     195             :                  size_type __n, const _Alloc& __a)
     196             :     : _M_dataplus(_S_construct(__str._M_data()
     197             :                                + __str._M_check(__pos,
     198             :                                                 "basic_string::basic_string"),
     199             :                                __str._M_data() + __str._M_limit(__pos, __n)
     200             :                                + __pos, __a), __a)
     201             :     { }
     202             : 
     203             :   // TBD: DPG annotate
     204             :   template<typename _CharT, typename _Traits, typename _Alloc>
     205             :     basic_string<_CharT, _Traits, _Alloc>::
     206             :     basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
     207             :     : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
     208             :     { }
     209             : 
     210             :   // TBD: DPG annotate
     211             :   template<typename _CharT, typename _Traits, typename _Alloc>
     212             :     basic_string<_CharT, _Traits, _Alloc>::
     213             :     basic_string(const _CharT* __s, const _Alloc& __a)
     214             :     : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
     215             :                                __s + npos, __a), __a)
     216             :     { }
     217             : 
     218             :   template<typename _CharT, typename _Traits, typename _Alloc>
     219             :     basic_string<_CharT, _Traits, _Alloc>::
     220             :     basic_string(size_type __n, _CharT __c, const _Alloc& __a)
     221             :     : _M_dataplus(_S_construct(__n, __c, __a), __a)
     222             :     { }
     223             : 
     224             :   // TBD: DPG annotate
     225             :   template<typename _CharT, typename _Traits, typename _Alloc>
     226             :     template<typename _InputIterator>
     227          64 :     basic_string<_CharT, _Traits, _Alloc>::
     228             :     basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
     229          64 :     : _M_dataplus(_S_construct(__beg, __end, __a), __a)
     230          64 :     { }
     231             : 
     232             : #if __cplusplus >= 201103L
     233             :   template<typename _CharT, typename _Traits, typename _Alloc>
     234             :     basic_string<_CharT, _Traits, _Alloc>::
     235             :     basic_string(initializer_list<_CharT> __l, const _Alloc& __a)
     236             :     : _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a)
     237             :     { }
     238             : #endif
     239             : 
     240             :   template<typename _CharT, typename _Traits, typename _Alloc>
     241             :     basic_string<_CharT, _Traits, _Alloc>&
     242             :     basic_string<_CharT, _Traits, _Alloc>::
     243             :     assign(const basic_string& __str)
     244             :     {
     245             :       if (_M_rep() != __str._M_rep())
     246             :         {
     247             :           // XXX MT
     248             :           const allocator_type __a = this->get_allocator();
     249             :           _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
     250             :           _M_rep()->_M_dispose(__a);
     251             :           _M_data(__tmp);
     252             :         }
     253             :       return *this;
     254             :     }
     255             : 
     256             :   template<typename _CharT, typename _Traits, typename _Alloc>
     257             :     basic_string<_CharT, _Traits, _Alloc>&
     258             :     basic_string<_CharT, _Traits, _Alloc>::
     259             :     assign(const _CharT* __s, size_type __n)
     260             :     {
     261             :       __glibcxx_requires_string_len(__s, __n);
     262             :       _M_check_length(this->size(), __n, "basic_string::assign");
     263             :       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
     264             :         return _M_replace_safe(size_type(0), this->size(), __s, __n);
     265             :       else
     266             :         {
     267             :           // Work in-place.
     268             :           const size_type __pos = __s - _M_data();
     269             :           if (__pos >= __n)
     270             :             _M_copy(_M_data(), __s, __n);
     271             :           else if (__pos)
     272             :             _M_move(_M_data(), __s, __n);
     273             :           _M_rep()->_M_set_length_and_sharable(__n);
     274             :           return *this;
     275             :         }
     276             :      }
     277             : 
     278             :   template<typename _CharT, typename _Traits, typename _Alloc>
     279             :     basic_string<_CharT, _Traits, _Alloc>&
     280             :     basic_string<_CharT, _Traits, _Alloc>::
     281             :     append(size_type __n, _CharT __c)
     282             :     {
     283             :       if (__n)
     284             :         {
     285             :           _M_check_length(size_type(0), __n, "basic_string::append");   
     286             :           const size_type __len = __n + this->size();
     287             :           if (__len > this->capacity() || _M_rep()->_M_is_shared())
     288             :             this->reserve(__len);
     289             :           _M_assign(_M_data() + this->size(), __n, __c);
     290             :           _M_rep()->_M_set_length_and_sharable(__len);
     291             :         }
     292             :       return *this;
     293             :     }
     294             : 
     295             :   template<typename _CharT, typename _Traits, typename _Alloc>
     296             :     basic_string<_CharT, _Traits, _Alloc>&
     297             :     basic_string<_CharT, _Traits, _Alloc>::
     298             :     append(const _CharT* __s, size_type __n)
     299             :     {
     300             :       __glibcxx_requires_string_len(__s, __n);
     301             :       if (__n)
     302             :         {
     303             :           _M_check_length(size_type(0), __n, "basic_string::append");
     304             :           const size_type __len = __n + this->size();
     305             :           if (__len > this->capacity() || _M_rep()->_M_is_shared())
     306             :             {
     307             :               if (_M_disjunct(__s))
     308             :                 this->reserve(__len);
     309             :               else
     310             :                 {
     311             :                   const size_type __off = __s - _M_data();
     312             :                   this->reserve(__len);
     313             :                   __s = _M_data() + __off;
     314             :                 }
     315             :             }
     316             :           _M_copy(_M_data() + this->size(), __s, __n);
     317             :           _M_rep()->_M_set_length_and_sharable(__len);
     318             :         }
     319             :       return *this;
     320             :     }
     321             : 
     322             :   template<typename _CharT, typename _Traits, typename _Alloc>
     323             :     basic_string<_CharT, _Traits, _Alloc>&
     324             :     basic_string<_CharT, _Traits, _Alloc>::
     325             :     append(const basic_string& __str)
     326             :     {
     327             :       const size_type __size = __str.size();
     328             :       if (__size)
     329             :         {
     330             :           const size_type __len = __size + this->size();
     331             :           if (__len > this->capacity() || _M_rep()->_M_is_shared())
     332             :             this->reserve(__len);
     333             :           _M_copy(_M_data() + this->size(), __str._M_data(), __size);
     334             :           _M_rep()->_M_set_length_and_sharable(__len);
     335             :         }
     336             :       return *this;
     337             :     }    
     338             : 
     339             :   template<typename _CharT, typename _Traits, typename _Alloc>
     340             :     basic_string<_CharT, _Traits, _Alloc>&
     341             :     basic_string<_CharT, _Traits, _Alloc>::
     342             :     append(const basic_string& __str, size_type __pos, size_type __n)
     343             :     {
     344             :       __str._M_check(__pos, "basic_string::append");
     345             :       __n = __str._M_limit(__pos, __n);
     346             :       if (__n)
     347             :         {
     348             :           const size_type __len = __n + this->size();
     349             :           if (__len > this->capacity() || _M_rep()->_M_is_shared())
     350             :             this->reserve(__len);
     351             :           _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
     352             :           _M_rep()->_M_set_length_and_sharable(__len);         
     353             :         }
     354             :       return *this;
     355             :     }
     356             : 
     357             :    template<typename _CharT, typename _Traits, typename _Alloc>
     358             :      basic_string<_CharT, _Traits, _Alloc>&
     359             :      basic_string<_CharT, _Traits, _Alloc>::
     360             :      insert(size_type __pos, const _CharT* __s, size_type __n)
     361             :      {
     362             :        __glibcxx_requires_string_len(__s, __n);
     363             :        _M_check(__pos, "basic_string::insert");
     364             :        _M_check_length(size_type(0), __n, "basic_string::insert");
     365             :        if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
     366             :          return _M_replace_safe(__pos, size_type(0), __s, __n);
     367             :        else
     368             :          {
     369             :            // Work in-place.
     370             :            const size_type __off = __s - _M_data();
     371             :            _M_mutate(__pos, 0, __n);
     372             :            __s = _M_data() + __off;
     373             :            _CharT* __p = _M_data() + __pos;
     374             :            if (__s  + __n <= __p)
     375             :              _M_copy(__p, __s, __n);
     376             :            else if (__s >= __p)
     377             :              _M_copy(__p, __s + __n, __n);
     378             :            else
     379             :              {
     380             :                const size_type __nleft = __p - __s;
     381             :                _M_copy(__p, __s, __nleft);
     382             :                _M_copy(__p + __nleft, __p + __n, __n - __nleft);
     383             :              }
     384             :            return *this;
     385             :          }
     386             :      }
     387             : 
     388             :    template<typename _CharT, typename _Traits, typename _Alloc>
     389             :      typename basic_string<_CharT, _Traits, _Alloc>::iterator
     390             :      basic_string<_CharT, _Traits, _Alloc>::
     391             :      erase(iterator __first, iterator __last)
     392             :      {
     393             :        _GLIBCXX_DEBUG_PEDASSERT(__first >= _M_ibegin() && __first <= __last
     394             :                                 && __last <= _M_iend());
     395             : 
     396             :        // NB: This isn't just an optimization (bail out early when
     397             :        // there is nothing to do, really), it's also a correctness
     398             :        // issue vs MT, see libstdc++/40518.
     399             :        const size_type __size = __last - __first;
     400             :        if (__size)
     401             :          {
     402             :            const size_type __pos = __first - _M_ibegin();
     403             :            _M_mutate(__pos, __size, size_type(0));
     404             :            _M_rep()->_M_set_leaked();
     405             :            return iterator(_M_data() + __pos);
     406             :          }
     407             :        else
     408             :          return __first;
     409             :      }
     410             : 
     411             :    template<typename _CharT, typename _Traits, typename _Alloc>
     412             :      basic_string<_CharT, _Traits, _Alloc>&
     413             :      basic_string<_CharT, _Traits, _Alloc>::
     414             :      replace(size_type __pos, size_type __n1, const _CharT* __s,
     415             :              size_type __n2)
     416             :      {
     417             :        __glibcxx_requires_string_len(__s, __n2);
     418             :        _M_check(__pos, "basic_string::replace");
     419             :        __n1 = _M_limit(__pos, __n1);
     420             :        _M_check_length(__n1, __n2, "basic_string::replace");
     421             :        bool __left;
     422             :        if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
     423             :          return _M_replace_safe(__pos, __n1, __s, __n2);
     424             :        else if ((__left = __s + __n2 <= _M_data() + __pos)
     425             :                 || _M_data() + __pos + __n1 <= __s)
     426             :          {
     427             :            // Work in-place: non-overlapping case.
     428             :            size_type __off = __s - _M_data();
     429             :            __left ? __off : (__off += __n2 - __n1);
     430             :            _M_mutate(__pos, __n1, __n2);
     431             :            _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
     432             :            return *this;
     433             :          }
     434             :        else
     435             :          {
     436             :            // Todo: overlapping case.
     437             :            const basic_string __tmp(__s, __n2);
     438             :            return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
     439             :          }
     440             :      }
     441             : 
     442             :   template<typename _CharT, typename _Traits, typename _Alloc>
     443             :     void
     444             :     basic_string<_CharT, _Traits, _Alloc>::_Rep::
     445             :     _M_destroy(const _Alloc& __a) throw ()
     446             :     {
     447             :       const size_type __size = sizeof(_Rep_base) +
     448             :                                (this->_M_capacity + 1) * sizeof(_CharT);
     449             :       _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
     450             :     }
     451             : 
     452             :   template<typename _CharT, typename _Traits, typename _Alloc>
     453             :     void
     454             :     basic_string<_CharT, _Traits, _Alloc>::
     455             :     _M_leak_hard()
     456             :     {
     457             : #if _GLIBCXX_FULLY_DYNAMIC_STRING == 0
     458             :       if (_M_rep() == &_S_empty_rep())
     459             :         return;
     460             : #endif
     461             :       if (_M_rep()->_M_is_shared())
     462             :         _M_mutate(0, 0, 0);
     463             :       _M_rep()->_M_set_leaked();
     464             :     }
     465             : 
     466             :   template<typename _CharT, typename _Traits, typename _Alloc>
     467             :     void
     468             :     basic_string<_CharT, _Traits, _Alloc>::
     469             :     _M_mutate(size_type __pos, size_type __len1, size_type __len2)
     470             :     {
     471             :       const size_type __old_size = this->size();
     472             :       const size_type __new_size = __old_size + __len2 - __len1;
     473             :       const size_type __how_much = __old_size - __pos - __len1;
     474             : 
     475             :       if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
     476             :         {
     477             :           // Must reallocate.
     478             :           const allocator_type __a = get_allocator();
     479             :           _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
     480             : 
     481             :           if (__pos)
     482             :             _M_copy(__r->_M_refdata(), _M_data(), __pos);
     483             :           if (__how_much)
     484             :             _M_copy(__r->_M_refdata() + __pos + __len2,
     485             :                     _M_data() + __pos + __len1, __how_much);
     486             : 
     487             :           _M_rep()->_M_dispose(__a);
     488             :           _M_data(__r->_M_refdata());
     489             :         }
     490             :       else if (__how_much && __len1 != __len2)
     491             :         {
     492             :           // Work in-place.
     493             :           _M_move(_M_data() + __pos + __len2,
     494             :                   _M_data() + __pos + __len1, __how_much);
     495             :         }
     496             :       _M_rep()->_M_set_length_and_sharable(__new_size);
     497             :     }
     498             : 
     499             :   template<typename _CharT, typename _Traits, typename _Alloc>
     500             :     void
     501             :     basic_string<_CharT, _Traits, _Alloc>::
     502             :     reserve(size_type __res)
     503             :     {
     504             :       if (__res != this->capacity() || _M_rep()->_M_is_shared())
     505             :         {
     506             :           // Make sure we don't shrink below the current size
     507             :           if (__res < this->size())
     508             :             __res = this->size();
     509             :           const allocator_type __a = get_allocator();
     510             :           _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
     511             :           _M_rep()->_M_dispose(__a);
     512             :           _M_data(__tmp);
     513             :         }
     514             :     }
     515             : 
     516             :   template<typename _CharT, typename _Traits, typename _Alloc>
     517             :     void
     518             :     basic_string<_CharT, _Traits, _Alloc>::
     519             :     swap(basic_string& __s)
     520             :     {
     521             :       if (_M_rep()->_M_is_leaked())
     522             :         _M_rep()->_M_set_sharable();
     523             :       if (__s._M_rep()->_M_is_leaked())
     524             :         __s._M_rep()->_M_set_sharable();
     525             :       if (this->get_allocator() == __s.get_allocator())
     526             :         {
     527             :           _CharT* __tmp = _M_data();
     528             :           _M_data(__s._M_data());
     529             :           __s._M_data(__tmp);
     530             :         }
     531             :       // The code below can usually be optimized away.
     532             :       else
     533             :         {
     534             :           const basic_string __tmp1(_M_ibegin(), _M_iend(),
     535             :                                     __s.get_allocator());
     536             :           const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
     537             :                                     this->get_allocator());
     538             :           *this = __tmp2;
     539             :           __s = __tmp1;
     540             :         }
     541             :     }
     542             : 
     543             :   template<typename _CharT, typename _Traits, typename _Alloc>
     544             :     typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
     545             :     basic_string<_CharT, _Traits, _Alloc>::_Rep::
     546             :     _S_create(size_type __capacity, size_type __old_capacity,
     547             :               const _Alloc& __alloc)
     548             :     {
     549             :       // _GLIBCXX_RESOLVE_LIB_DEFECTS
     550             :       // 83.  String::npos vs. string::max_size()
     551             :       if (__capacity > _S_max_size)
     552             :         __throw_length_error(__N("basic_string::_S_create"));
     553             : 
     554             :       // The standard places no restriction on allocating more memory
     555             :       // than is strictly needed within this layer at the moment or as
     556             :       // requested by an explicit application call to reserve().
     557             : 
     558             :       // Many malloc implementations perform quite poorly when an
     559             :       // application attempts to allocate memory in a stepwise fashion
     560             :       // growing each allocation size by only 1 char.  Additionally,
     561             :       // it makes little sense to allocate less linear memory than the
     562             :       // natural blocking size of the malloc implementation.
     563             :       // Unfortunately, we would need a somewhat low-level calculation
     564             :       // with tuned parameters to get this perfect for any particular
     565             :       // malloc implementation.  Fortunately, generalizations about
     566             :       // common features seen among implementations seems to suffice.
     567             : 
     568             :       // __pagesize need not match the actual VM page size for good
     569             :       // results in practice, thus we pick a common value on the low
     570             :       // side.  __malloc_header_size is an estimate of the amount of
     571             :       // overhead per memory allocation (in practice seen N * sizeof
     572             :       // (void*) where N is 0, 2 or 4).  According to folklore,
     573             :       // picking this value on the high side is better than
     574             :       // low-balling it (especially when this algorithm is used with
     575             :       // malloc implementations that allocate memory blocks rounded up
     576             :       // to a size which is a power of 2).
     577             :       const size_type __pagesize = 4096;
     578             :       const size_type __malloc_header_size = 4 * sizeof(void*);
     579             : 
     580             :       // The below implements an exponential growth policy, necessary to
     581             :       // meet amortized linear time requirements of the library: see
     582             :       // http://gcc.gnu.org/ml/libstdc++/2001-07/msg00085.html.
     583             :       // It's active for allocations requiring an amount of memory above
     584             :       // system pagesize. This is consistent with the requirements of the
     585             :       // standard: http://gcc.gnu.org/ml/libstdc++/2001-07/msg00130.html
     586             :       if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
     587             :         __capacity = 2 * __old_capacity;
     588             : 
     589             :       // NB: Need an array of char_type[__capacity], plus a terminating
     590             :       // null char_type() element, plus enough for the _Rep data structure.
     591             :       // Whew. Seemingly so needy, yet so elemental.
     592             :       size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
     593             : 
     594             :       const size_type __adj_size = __size + __malloc_header_size;
     595             :       if (__adj_size > __pagesize && __capacity > __old_capacity)
     596             :         {
     597             :           const size_type __extra = __pagesize - __adj_size % __pagesize;
     598             :           __capacity += __extra / sizeof(_CharT);
     599             :           // Never allocate a string bigger than _S_max_size.
     600             :           if (__capacity > _S_max_size)
     601             :             __capacity = _S_max_size;
     602             :           __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
     603             :         }
     604             : 
     605             :       // NB: Might throw, but no worries about a leak, mate: _Rep()
     606             :       // does not throw.
     607             :       void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
     608             :       _Rep *__p = new (__place) _Rep;
     609             :       __p->_M_capacity = __capacity;
     610             :       // ABI compatibility - 3.4.x set in _S_create both
     611             :       // _M_refcount and _M_length.  All callers of _S_create
     612             :       // in basic_string.tcc then set just _M_length.
     613             :       // In 4.0.x and later both _M_refcount and _M_length
     614             :       // are initialized in the callers, unfortunately we can
     615             :       // have 3.4.x compiled code with _S_create callers inlined
     616             :       // calling 4.0.x+ _S_create.
     617             :       __p->_M_set_sharable();
     618             :       return __p;
     619             :     }
     620             : 
     621             :   template<typename _CharT, typename _Traits, typename _Alloc>
     622             :     _CharT*
     623             :     basic_string<_CharT, _Traits, _Alloc>::_Rep::
     624             :     _M_clone(const _Alloc& __alloc, size_type __res)
     625             :     {
     626             :       // Requested capacity of the clone.
     627             :       const size_type __requested_cap = this->_M_length + __res;
     628             :       _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
     629             :                                   __alloc);
     630             :       if (this->_M_length)
     631             :         _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
     632             : 
     633             :       __r->_M_set_length_and_sharable(this->_M_length);
     634             :       return __r->_M_refdata();
     635             :     }
     636             : 
     637             :   template<typename _CharT, typename _Traits, typename _Alloc>
     638             :     void
     639             :     basic_string<_CharT, _Traits, _Alloc>::
     640             :     resize(size_type __n, _CharT __c)
     641             :     {
     642             :       const size_type __size = this->size();
     643             :       _M_check_length(__size, __n, "basic_string::resize");
     644             :       if (__size < __n)
     645             :         this->append(__n - __size, __c);
     646             :       else if (__n < __size)
     647             :         this->erase(__n);
     648             :       // else nothing (in particular, avoid calling _M_mutate() unnecessarily.)
     649             :     }
     650             : 
     651             :   template<typename _CharT, typename _Traits, typename _Alloc>
     652             :     template<typename _InputIterator>
     653             :       basic_string<_CharT, _Traits, _Alloc>&
     654             :       basic_string<_CharT, _Traits, _Alloc>::
     655             :       _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
     656             :                           _InputIterator __k2, __false_type)
     657             :       {
     658             :         const basic_string __s(__k1, __k2);
     659             :         const size_type __n1 = __i2 - __i1;
     660             :         _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
     661             :         return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
     662             :                                __s.size());
     663             :       }
     664             : 
     665             :   template<typename _CharT, typename _Traits, typename _Alloc>
     666             :     basic_string<_CharT, _Traits, _Alloc>&
     667             :     basic_string<_CharT, _Traits, _Alloc>::
     668             :     _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
     669             :                    _CharT __c)
     670             :     {
     671             :       _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
     672             :       _M_mutate(__pos1, __n1, __n2);
     673             :       if (__n2)
     674             :         _M_assign(_M_data() + __pos1, __n2, __c);
     675             :       return *this;
     676             :     }
     677             : 
     678             :   template<typename _CharT, typename _Traits, typename _Alloc>
     679             :     basic_string<_CharT, _Traits, _Alloc>&
     680             :     basic_string<_CharT, _Traits, _Alloc>::
     681             :     _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
     682             :                     size_type __n2)
     683             :     {
     684             :       _M_mutate(__pos1, __n1, __n2);
     685             :       if (__n2)
     686             :         _M_copy(_M_data() + __pos1, __s, __n2);
     687             :       return *this;
     688             :     }
     689             :    
     690             :   template<typename _CharT, typename _Traits, typename _Alloc>
     691             :     basic_string<_CharT, _Traits, _Alloc>
     692             :     operator+(const _CharT* __lhs,
     693             :               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
     694             :     {
     695             :       __glibcxx_requires_string(__lhs);
     696             :       typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
     697             :       typedef typename __string_type::size_type   __size_type;
     698             :       const __size_type __len = _Traits::length(__lhs);
     699             :       __string_type __str;
     700             :       __str.reserve(__len + __rhs.size());
     701             :       __str.append(__lhs, __len);
     702             :       __str.append(__rhs);
     703             :       return __str;
     704             :     }
     705             : 
     706             :   template<typename _CharT, typename _Traits, typename _Alloc>
     707             :     basic_string<_CharT, _Traits, _Alloc>
     708             :     operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
     709             :     {
     710             :       typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
     711             :       typedef typename __string_type::size_type   __size_type;
     712             :       __string_type __str;
     713             :       const __size_type __len = __rhs.size();
     714             :       __str.reserve(__len + 1);
     715             :       __str.append(__size_type(1), __lhs);
     716             :       __str.append(__rhs);
     717             :       return __str;
     718             :     }
     719             : 
     720             :   template<typename _CharT, typename _Traits, typename _Alloc>
     721             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     722             :     basic_string<_CharT, _Traits, _Alloc>::
     723             :     copy(_CharT* __s, size_type __n, size_type __pos) const
     724             :     {
     725             :       _M_check(__pos, "basic_string::copy");
     726             :       __n = _M_limit(__pos, __n);
     727             :       __glibcxx_requires_string_len(__s, __n);
     728             :       if (__n)
     729             :         _M_copy(__s, _M_data() + __pos, __n);
     730             :       // 21.3.5.7 par 3: do not append null.  (good.)
     731             :       return __n;
     732             :     }
     733             : 
     734             :   template<typename _CharT, typename _Traits, typename _Alloc>
     735             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     736             :     basic_string<_CharT, _Traits, _Alloc>::
     737             :     find(const _CharT* __s, size_type __pos, size_type __n) const
     738             :     {
     739             :       __glibcxx_requires_string_len(__s, __n);
     740             :       const size_type __size = this->size();
     741             :       const _CharT* __data = _M_data();
     742             : 
     743             :       if (__n == 0)
     744             :         return __pos <= __size ? __pos : npos;
     745             : 
     746             :       if (__n <= __size)
     747             :         {
     748             :           for (; __pos <= __size - __n; ++__pos)
     749             :             if (traits_type::eq(__data[__pos], __s[0])
     750             :                 && traits_type::compare(__data + __pos + 1,
     751             :                                         __s + 1, __n - 1) == 0)
     752             :               return __pos;
     753             :         }
     754             :       return npos;
     755             :     }
     756             : 
     757             :   template<typename _CharT, typename _Traits, typename _Alloc>
     758             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     759             :     basic_string<_CharT, _Traits, _Alloc>::
     760             :     find(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
     761             :     {
     762             :       size_type __ret = npos;
     763             :       const size_type __size = this->size();
     764             :       if (__pos < __size)
     765             :         {
     766             :           const _CharT* __data = _M_data();
     767             :           const size_type __n = __size - __pos;
     768             :           const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
     769             :           if (__p)
     770             :             __ret = __p - __data;
     771             :         }
     772             :       return __ret;
     773             :     }
     774             : 
     775             :   template<typename _CharT, typename _Traits, typename _Alloc>
     776             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     777             :     basic_string<_CharT, _Traits, _Alloc>::
     778             :     rfind(const _CharT* __s, size_type __pos, size_type __n) const
     779             :     {
     780             :       __glibcxx_requires_string_len(__s, __n);
     781             :       const size_type __size = this->size();
     782             :       if (__n <= __size)
     783             :         {
     784             :           __pos = std::min(size_type(__size - __n), __pos);
     785             :           const _CharT* __data = _M_data();
     786             :           do
     787             :             {
     788             :               if (traits_type::compare(__data + __pos, __s, __n) == 0)
     789             :                 return __pos;
     790             :             }
     791             :           while (__pos-- > 0);
     792             :         }
     793             :       return npos;
     794             :     }
     795             : 
     796             :   template<typename _CharT, typename _Traits, typename _Alloc>
     797             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     798             :     basic_string<_CharT, _Traits, _Alloc>::
     799             :     rfind(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
     800             :     {
     801             :       size_type __size = this->size();
     802             :       if (__size)
     803             :         {
     804             :           if (--__size > __pos)
     805             :             __size = __pos;
     806             :           for (++__size; __size-- > 0; )
     807             :             if (traits_type::eq(_M_data()[__size], __c))
     808             :               return __size;
     809             :         }
     810             :       return npos;
     811             :     }
     812             : 
     813             :   template<typename _CharT, typename _Traits, typename _Alloc>
     814             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     815             :     basic_string<_CharT, _Traits, _Alloc>::
     816             :     find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
     817             :     {
     818             :       __glibcxx_requires_string_len(__s, __n);
     819             :       for (; __n && __pos < this->size(); ++__pos)
     820             :         {
     821             :           const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
     822             :           if (__p)
     823             :             return __pos;
     824             :         }
     825             :       return npos;
     826             :     }
     827             : 
     828             :   template<typename _CharT, typename _Traits, typename _Alloc>
     829             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     830             :     basic_string<_CharT, _Traits, _Alloc>::
     831             :     find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
     832             :     {
     833             :       __glibcxx_requires_string_len(__s, __n);
     834             :       size_type __size = this->size();
     835             :       if (__size && __n)
     836             :         {
     837             :           if (--__size > __pos)
     838             :             __size = __pos;
     839             :           do
     840             :             {
     841             :               if (traits_type::find(__s, __n, _M_data()[__size]))
     842             :                 return __size;
     843             :             }
     844             :           while (__size-- != 0);
     845             :         }
     846             :       return npos;
     847             :     }
     848             : 
     849             :   template<typename _CharT, typename _Traits, typename _Alloc>
     850             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     851             :     basic_string<_CharT, _Traits, _Alloc>::
     852             :     find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
     853             :     {
     854             :       __glibcxx_requires_string_len(__s, __n);
     855             :       for (; __pos < this->size(); ++__pos)
     856             :         if (!traits_type::find(__s, __n, _M_data()[__pos]))
     857             :           return __pos;
     858             :       return npos;
     859             :     }
     860             : 
     861             :   template<typename _CharT, typename _Traits, typename _Alloc>
     862             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     863             :     basic_string<_CharT, _Traits, _Alloc>::
     864             :     find_first_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
     865             :     {
     866             :       for (; __pos < this->size(); ++__pos)
     867             :         if (!traits_type::eq(_M_data()[__pos], __c))
     868             :           return __pos;
     869             :       return npos;
     870             :     }
     871             : 
     872             :   template<typename _CharT, typename _Traits, typename _Alloc>
     873             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     874             :     basic_string<_CharT, _Traits, _Alloc>::
     875             :     find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
     876             :     {
     877             :       __glibcxx_requires_string_len(__s, __n);
     878             :       size_type __size = this->size();
     879             :       if (__size)
     880             :         {
     881             :           if (--__size > __pos)
     882             :             __size = __pos;
     883             :           do
     884             :             {
     885             :               if (!traits_type::find(__s, __n, _M_data()[__size]))
     886             :                 return __size;
     887             :             }
     888             :           while (__size--);
     889             :         }
     890             :       return npos;
     891             :     }
     892             : 
     893             :   template<typename _CharT, typename _Traits, typename _Alloc>
     894             :     typename basic_string<_CharT, _Traits, _Alloc>::size_type
     895             :     basic_string<_CharT, _Traits, _Alloc>::
     896             :     find_last_not_of(_CharT __c, size_type __pos) const _GLIBCXX_NOEXCEPT
     897             :     {
     898             :       size_type __size = this->size();
     899             :       if (__size)
     900             :         {
     901             :           if (--__size > __pos)
     902             :             __size = __pos;
     903             :           do
     904             :             {
     905             :               if (!traits_type::eq(_M_data()[__size], __c))
     906             :                 return __size;
     907             :             }
     908             :           while (__size--);
     909             :         }
     910             :       return npos;
     911             :     }
     912             : 
     913             :   template<typename _CharT, typename _Traits, typename _Alloc>
     914             :     int
     915             :     basic_string<_CharT, _Traits, _Alloc>::
     916             :     compare(size_type __pos, size_type __n, const basic_string& __str) const
     917             :     {
     918             :       _M_check(__pos, "basic_string::compare");
     919             :       __n = _M_limit(__pos, __n);
     920             :       const size_type __osize = __str.size();
     921             :       const size_type __len = std::min(__n, __osize);
     922             :       int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
     923             :       if (!__r)
     924             :         __r = _S_compare(__n, __osize);
     925             :       return __r;
     926             :     }
     927             : 
     928             :   template<typename _CharT, typename _Traits, typename _Alloc>
     929             :     int
     930             :     basic_string<_CharT, _Traits, _Alloc>::
     931             :     compare(size_type __pos1, size_type __n1, const basic_string& __str,
     932             :             size_type __pos2, size_type __n2) const
     933             :     {
     934             :       _M_check(__pos1, "basic_string::compare");
     935             :       __str._M_check(__pos2, "basic_string::compare");
     936             :       __n1 = _M_limit(__pos1, __n1);
     937             :       __n2 = __str._M_limit(__pos2, __n2);
     938             :       const size_type __len = std::min(__n1, __n2);
     939             :       int __r = traits_type::compare(_M_data() + __pos1,
     940             :                                      __str.data() + __pos2, __len);
     941             :       if (!__r)
     942             :         __r = _S_compare(__n1, __n2);
     943             :       return __r;
     944             :     }
     945             : 
     946             :   template<typename _CharT, typename _Traits, typename _Alloc>
     947             :     int
     948             :     basic_string<_CharT, _Traits, _Alloc>::
     949             :     compare(const _CharT* __s) const
     950             :     {
     951             :       __glibcxx_requires_string(__s);
     952             :       const size_type __size = this->size();
     953             :       const size_type __osize = traits_type::length(__s);
     954             :       const size_type __len = std::min(__size, __osize);
     955             :       int __r = traits_type::compare(_M_data(), __s, __len);
     956             :       if (!__r)
     957             :         __r = _S_compare(__size, __osize);
     958             :       return __r;
     959             :     }
     960             : 
     961             :   template<typename _CharT, typename _Traits, typename _Alloc>
     962             :     int
     963             :     basic_string <_CharT, _Traits, _Alloc>::
     964             :     compare(size_type __pos, size_type __n1, const _CharT* __s) const
     965             :     {
     966             :       __glibcxx_requires_string(__s);
     967             :       _M_check(__pos, "basic_string::compare");
     968             :       __n1 = _M_limit(__pos, __n1);
     969             :       const size_type __osize = traits_type::length(__s);
     970             :       const size_type __len = std::min(__n1, __osize);
     971             :       int __r = traits_type::compare(_M_data() + __pos, __s, __len);
     972             :       if (!__r)
     973             :         __r = _S_compare(__n1, __osize);
     974             :       return __r;
     975             :     }
     976             : 
     977             :   template<typename _CharT, typename _Traits, typename _Alloc>
     978             :     int
     979             :     basic_string <_CharT, _Traits, _Alloc>::
     980             :     compare(size_type __pos, size_type __n1, const _CharT* __s,
     981             :             size_type __n2) const
     982             :     {
     983             :       __glibcxx_requires_string_len(__s, __n2);
     984             :       _M_check(__pos, "basic_string::compare");
     985             :       __n1 = _M_limit(__pos, __n1);
     986             :       const size_type __len = std::min(__n1, __n2);
     987             :       int __r = traits_type::compare(_M_data() + __pos, __s, __len);
     988             :       if (!__r)
     989             :         __r = _S_compare(__n1, __n2);
     990             :       return __r;
     991             :     }
     992             : 
     993             :   // 21.3.7.9 basic_string::getline and operators
     994             :   template<typename _CharT, typename _Traits, typename _Alloc>
     995             :     basic_istream<_CharT, _Traits>&
     996             :     operator>>(basic_istream<_CharT, _Traits>& __in,
     997             :                basic_string<_CharT, _Traits, _Alloc>& __str)
     998             :     {
     999             :       typedef basic_istream<_CharT, _Traits>              __istream_type;
    1000             :       typedef basic_string<_CharT, _Traits, _Alloc>       __string_type;
    1001             :       typedef typename __istream_type::ios_base         __ios_base;
    1002             :       typedef typename __istream_type::int_type         __int_type;
    1003             :       typedef typename __string_type::size_type         __size_type;
    1004             :       typedef ctype<_CharT>                               __ctype_type;
    1005             :       typedef typename __ctype_type::ctype_base         __ctype_base;
    1006             : 
    1007             :       __size_type __extracted = 0;
    1008             :       typename __ios_base::iostate __err = __ios_base::goodbit;
    1009             :       typename __istream_type::sentry __cerb(__in, false);
    1010             :       if (__cerb)
    1011             :         {
    1012             :           __try
    1013             :             {
    1014             :               // Avoid reallocation for common case.
    1015             :               __str.erase();
    1016             :               _CharT __buf[128];
    1017             :               __size_type __len = 0;          
    1018             :               const streamsize __w = __in.width();
    1019             :               const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
    1020             :                                               : __str.max_size();
    1021             :               const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
    1022             :               const __int_type __eof = _Traits::eof();
    1023             :               __int_type __c = __in.rdbuf()->sgetc();
    1024             : 
    1025             :               while (__extracted < __n
    1026             :                      && !_Traits::eq_int_type(__c, __eof)
    1027             :                      && !__ct.is(__ctype_base::space,
    1028             :                                  _Traits::to_char_type(__c)))
    1029             :                 {
    1030             :                   if (__len == sizeof(__buf) / sizeof(_CharT))
    1031             :                     {
    1032             :                       __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
    1033             :                       __len = 0;
    1034             :                     }
    1035             :                   __buf[__len++] = _Traits::to_char_type(__c);
    1036             :                   ++__extracted;
    1037             :                   __c = __in.rdbuf()->snextc();
    1038             :                 }
    1039             :               __str.append(__buf, __len);
    1040             : 
    1041             :               if (_Traits::eq_int_type(__c, __eof))
    1042             :                 __err |= __ios_base::eofbit;
    1043             :               __in.width(0);
    1044             :             }
    1045             :           __catch(__cxxabiv1::__forced_unwind&)
    1046             :             {
    1047             :               __in._M_setstate(__ios_base::badbit);
    1048             :               __throw_exception_again;
    1049             :             }
    1050             :           __catch(...)
    1051             :             {
    1052             :               // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1053             :               // 91. Description of operator>> and getline() for string<>
    1054             :               // might cause endless loop
    1055             :               __in._M_setstate(__ios_base::badbit);
    1056             :             }
    1057             :         }
    1058             :       // 211.  operator>>(istream&, string&) doesn't set failbit
    1059             :       if (!__extracted)
    1060             :         __err |= __ios_base::failbit;
    1061             :       if (__err)
    1062             :         __in.setstate(__err);
    1063             :       return __in;
    1064             :     }
    1065             : 
    1066             :   template<typename _CharT, typename _Traits, typename _Alloc>
    1067             :     basic_istream<_CharT, _Traits>&
    1068             :     getline(basic_istream<_CharT, _Traits>& __in,
    1069             :             basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    1070             :     {
    1071             :       typedef basic_istream<_CharT, _Traits>              __istream_type;
    1072             :       typedef basic_string<_CharT, _Traits, _Alloc>       __string_type;
    1073             :       typedef typename __istream_type::ios_base         __ios_base;
    1074             :       typedef typename __istream_type::int_type         __int_type;
    1075             :       typedef typename __string_type::size_type         __size_type;
    1076             : 
    1077             :       __size_type __extracted = 0;
    1078             :       const __size_type __n = __str.max_size();
    1079             :       typename __ios_base::iostate __err = __ios_base::goodbit;
    1080             :       typename __istream_type::sentry __cerb(__in, true);
    1081             :       if (__cerb)
    1082             :         {
    1083             :           __try
    1084             :             {
    1085             :               __str.erase();
    1086             :               const __int_type __idelim = _Traits::to_int_type(__delim);
    1087             :               const __int_type __eof = _Traits::eof();
    1088             :               __int_type __c = __in.rdbuf()->sgetc();
    1089             : 
    1090             :               while (__extracted < __n
    1091             :                      && !_Traits::eq_int_type(__c, __eof)
    1092             :                      && !_Traits::eq_int_type(__c, __idelim))
    1093             :                 {
    1094             :                   __str += _Traits::to_char_type(__c);
    1095             :                   ++__extracted;
    1096             :                   __c = __in.rdbuf()->snextc();
    1097             :                 }
    1098             : 
    1099             :               if (_Traits::eq_int_type(__c, __eof))
    1100             :                 __err |= __ios_base::eofbit;
    1101             :               else if (_Traits::eq_int_type(__c, __idelim))
    1102             :                 {
    1103             :                   ++__extracted;                  
    1104             :                   __in.rdbuf()->sbumpc();
    1105             :                 }
    1106             :               else
    1107             :                 __err |= __ios_base::failbit;
    1108             :             }
    1109             :           __catch(__cxxabiv1::__forced_unwind&)
    1110             :             {
    1111             :               __in._M_setstate(__ios_base::badbit);
    1112             :               __throw_exception_again;
    1113             :             }
    1114             :           __catch(...)
    1115             :             {
    1116             :               // _GLIBCXX_RESOLVE_LIB_DEFECTS
    1117             :               // 91. Description of operator>> and getline() for string<>
    1118             :               // might cause endless loop
    1119             :               __in._M_setstate(__ios_base::badbit);
    1120             :             }
    1121             :         }
    1122             :       if (!__extracted)
    1123             :         __err |= __ios_base::failbit;
    1124             :       if (__err)
    1125             :         __in.setstate(__err);
    1126             :       return __in;
    1127             :     }
    1128             : 
    1129             :   // Inhibit implicit instantiations for required instantiations,
    1130             :   // which are defined via explicit instantiations elsewhere.
    1131             : #if _GLIBCXX_EXTERN_TEMPLATE > 0
    1132             :   extern template class basic_string<char>;
    1133             :   extern template
    1134             :     basic_istream<char>&
    1135             :     operator>>(basic_istream<char>&, string&);
    1136             :   extern template
    1137             :     basic_ostream<char>&
    1138             :     operator<<(basic_ostream<char>&, const string&);
    1139             :   extern template
    1140             :     basic_istream<char>&
    1141             :     getline(basic_istream<char>&, string&, char);
    1142             :   extern template
    1143             :     basic_istream<char>&
    1144             :     getline(basic_istream<char>&, string&);
    1145             : 
    1146             : #ifdef _GLIBCXX_USE_WCHAR_T
    1147             :   extern template class basic_string<wchar_t>;
    1148             :   extern template
    1149             :     basic_istream<wchar_t>&
    1150             :     operator>>(basic_istream<wchar_t>&, wstring&);
    1151             :   extern template
    1152             :     basic_ostream<wchar_t>&
    1153             :     operator<<(basic_ostream<wchar_t>&, const wstring&);
    1154             :   extern template
    1155             :     basic_istream<wchar_t>&
    1156             :     getline(basic_istream<wchar_t>&, wstring&, wchar_t);
    1157             :   extern template
    1158             :     basic_istream<wchar_t>&
    1159             :     getline(basic_istream<wchar_t>&, wstring&);
    1160             : #endif
    1161             : #endif
    1162             : 
    1163             : _GLIBCXX_END_NAMESPACE_VERSION
    1164             : } // namespace std
    1165             : 
    1166             : #endif

Generated by: LCOV version 1.11