libstdc++-v3/include/debug/string

   1 // Debugging string implementation -*- C++ -*-
   2
   3 // Copyright (C) 2003-2020 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 debug/string
  26  *  This file is a GNU debug extension to the Standard C++ Library.
  27  */
  28
  29 #ifndef _GLIBCXX_DEBUG_STRING
  30 #define _GLIBCXX_DEBUG_STRING 1
  31
  32 #pragma GCC system_header
  33
  34 #include <string>
  35 #include <debug/safe_sequence.h>
  36 #include <debug/safe_container.h>
  37 #include <debug/safe_iterator.h>
  38
  39 #define _GLIBCXX_DEBUG_VERIFY_STR_COND_AT(_Cond,_File,_Line,_Func)      \
  40   if (! (_Cond))                                                        \
  41     __gnu_debug::_Error_formatter::_S_at(_File, _Line, _Func)           \
  42       ._M_message(#_Cond)._M_error()
  43
  44 namespace __gnu_debug
  45 {
  46   /** Checks that __s is non-NULL or __n == 0, and then returns __s. */
  47   template<typename _CharT, typename _Integer>
  48     inline const _CharT*
  49     __check_string(const _CharT* __s,
  50                    _Integer __n __attribute__((__unused__)),
  51                    const char* __file __attribute__((__unused__)),
  52                    unsigned int __line __attribute__((__unused__)),
  53                    const char* __function __attribute__((__unused__)))
  54     {
  55 #ifdef _GLIBCXX_DEBUG_PEDANTIC
  56       _GLIBCXX_DEBUG_VERIFY_STR_COND_AT(__s != 0 || __n == 0,
  57                                         __file, __line, __function);
  58 #endif
  59       return __s;
  60     }
  61
  62   /** Checks that __s is non-NULL and then returns __s. */
  63   template<typename _CharT>
  64     inline const _CharT*
  65     __check_string(const _CharT* __s,
  66                    const char* __file __attribute__((__unused__)),
  67                    unsigned int __line __attribute__((__unused__)),
  68                    const char* __function __attribute__((__unused__)))
  69     {
  70 #ifdef _GLIBCXX_DEBUG_PEDANTIC
  71       _GLIBCXX_DEBUG_VERIFY_STR_COND_AT(__s != 0,
  72                                         __file, __line, __function);
  73 #endif
  74       return __s;
  75     }
  76
  77 #define __glibcxx_check_string_n_constructor(_Str, _Size) \
  78   __check_string(_Str, _Size, __FILE__, __LINE__, __PRETTY_FUNCTION__)
  79
  80 #define __glibcxx_check_string_constructor(_Str) \
  81   __check_string(_Str, __FILE__, __LINE__, __PRETTY_FUNCTION__)
  82
  83   /// Class std::basic_string with safety/checking/debug instrumentation.
  84   template<typename _CharT, typename _Traits = std::char_traits<_CharT>,
  85            typename _Allocator = std::allocator<_CharT> >
  86     class basic_string
  87       : public __gnu_debug::_Safe_container<
  88           basic_string<_CharT, _Traits, _Allocator>,
  89           _Allocator, _Safe_sequence, bool(_GLIBCXX_USE_CXX11_ABI)>,
  90         public std::basic_string<_CharT, _Traits, _Allocator>
  91     {
  92       typedef std::basic_string<_CharT, _Traits, _Allocator>    _Base;
  93       typedef __gnu_debug::_Safe_container<
  94         basic_string, _Allocator, _Safe_sequence, bool(_GLIBCXX_USE_CXX11_ABI)>
  95       _Safe;
  96
  97       template<typename _ItT, typename _SeqT, typename _CatT>
  98         friend class ::__gnu_debug::_Safe_iterator;
  99
 100       // type used for positions in insert, erase etc.
 101       typedef __gnu_debug::_Safe_iterator<
 102         typename _Base::__const_iterator, basic_string> __const_iterator;
 103
 104     public:
 105       // types:
 106       typedef _Traits                                   traits_type;
 107       typedef typename _Traits::char_type               value_type;
 108       typedef _Allocator                                allocator_type;
 109       typedef typename _Base::size_type                 size_type;
 110       typedef typename _Base::difference_type           difference_type;
 111       typedef typename _Base::reference                 reference;
 112       typedef typename _Base::const_reference           const_reference;
 113       typedef typename _Base::pointer                   pointer;
 114       typedef typename _Base::const_pointer             const_pointer;
 115
 116       typedef __gnu_debug::_Safe_iterator<
 117         typename _Base::iterator, basic_string>         iterator;
 118       typedef __gnu_debug::_Safe_iterator<
 119         typename _Base::const_iterator, basic_string>   const_iterator;
 120
 121       typedef std::reverse_iterator<iterator>           reverse_iterator;
 122       typedef std::reverse_iterator<const_iterator>     const_reverse_iterator;
 123
 124       using _Base::npos;
 125
 126       basic_string()
 127         _GLIBCXX_NOEXCEPT_IF(std::is_nothrow_default_constructible<_Base>::value)
 128         : _Base() { }
 129
 130       // 21.3.1 construct/copy/destroy:
 131       explicit
 132       basic_string(const _Allocator& __a) _GLIBCXX_NOEXCEPT
 133       : _Base(__a) { }
 134
 135 #if __cplusplus < 201103L
 136       basic_string(const basic_string& __str)
 137       : _Base(__str) { }
 138
 139       ~basic_string() { }
 140 #else
 141       basic_string(const basic_string&) = default;
 142       basic_string(basic_string&&) = default;
 143
 144       basic_string(std::initializer_list<_CharT> __l,
 145                    const _Allocator& __a = _Allocator())
 146       : _Base(__l, __a)
 147       { }
 148
 149 #if _GLIBCXX_USE_CXX11_ABI
 150       basic_string(const basic_string& __s, const _Allocator& __a)
 151       : _Base(__s, __a) { }
 152
 153       basic_string(basic_string&& __s, const _Allocator& __a)
 154       : _Base(std::move(__s), __a) { }
 155 #endif
 156
 157       ~basic_string() = default;
 158
 159       // Provides conversion from a normal-mode string to a debug-mode string
 160       basic_string(_Base&& __base) noexcept
 161       : _Base(std::move(__base)) { }
 162 #endif // C++11
 163
 164       // Provides conversion from a normal-mode string to a debug-mode string
 165       basic_string(const _Base& __base)
 166       : _Base(__base) { }
 167
 168       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 169       // 42. string ctors specify wrong default allocator
 170       basic_string(const basic_string& __str, size_type __pos,
 171                    size_type __n = _Base::npos,
 172                    const _Allocator& __a = _Allocator())
 173       : _Base(__str, __pos, __n, __a) { }
 174
 175       basic_string(const _CharT* __s, size_type __n,
 176                    const _Allocator& __a = _Allocator())
 177       : _Base(__glibcxx_check_string_n_constructor(__s, __n), __n, __a) { }
 178
 179       basic_string(const _CharT* __s, const _Allocator& __a = _Allocator())
 180       : _Base(__glibcxx_check_string_constructor(__s), __a)
 181       { this->assign(__s); }
 182
 183       basic_string(size_type __n, _CharT __c,
 184                    const _Allocator& __a = _Allocator())
 185       : _Base(__n, __c, __a) { }
 186
 187       template<typename _InputIterator>
 188         basic_string(_InputIterator __begin, _InputIterator __end,
 189                      const _Allocator& __a = _Allocator())
 190         : _Base(__gnu_debug::__base(
 191                   __glibcxx_check_valid_constructor_range(__begin, __end)),
 192                 __gnu_debug::__base(__end), __a) { }
 193
 194 #if __cplusplus < 201103L
 195       basic_string&
 196       operator=(const basic_string& __str)
 197       {
 198         this->_M_safe() = __str;
 199         _M_base() = __str;
 200         return *this;
 201       }
 202 #else
 203       basic_string&
 204       operator=(const basic_string&) = default;
 205
 206       basic_string&
 207       operator=(basic_string&&) = default;
 208 #endif
 209
 210       basic_string&
 211       operator=(const _CharT* __s)
 212       {
 213         __glibcxx_check_string(__s);
 214         _M_base() = __s;
 215         this->_M_invalidate_all();
 216         return *this;
 217       }
 218
 219       basic_string&
 220       operator=(_CharT __c)
 221       {
 222         _M_base() = __c;
 223         this->_M_invalidate_all();
 224         return *this;
 225       }
 226
 227 #if __cplusplus >= 201103L
 228       basic_string&
 229       operator=(std::initializer_list<_CharT> __l)
 230       {
 231         _M_base() = __l;
 232         this->_M_invalidate_all();
 233         return *this;
 234       }
 235 #endif // C++11
 236
 237       // 21.3.2 iterators:
 238       iterator
 239       begin() // _GLIBCXX_NOEXCEPT
 240       { return iterator(_Base::begin(), this); }
 241
 242       const_iterator
 243       begin() const _GLIBCXX_NOEXCEPT
 244       { return const_iterator(_Base::begin(), this); }
 245
 246       iterator
 247       end() // _GLIBCXX_NOEXCEPT
 248       { return iterator(_Base::end(), this); }
 249
 250       const_iterator
 251       end() const _GLIBCXX_NOEXCEPT
 252       { return const_iterator(_Base::end(), this); }
 253
 254       reverse_iterator
 255       rbegin() // _GLIBCXX_NOEXCEPT
 256       { return reverse_iterator(end()); }
 257
 258       const_reverse_iterator
 259       rbegin() const _GLIBCXX_NOEXCEPT
 260       { return const_reverse_iterator(end()); }
 261
 262       reverse_iterator
 263       rend() // _GLIBCXX_NOEXCEPT
 264       { return reverse_iterator(begin()); }
 265
 266       const_reverse_iterator
 267       rend() const _GLIBCXX_NOEXCEPT
 268       { return const_reverse_iterator(begin()); }
 269
 270 #if __cplusplus >= 201103L
 271       const_iterator
 272       cbegin() const noexcept
 273       { return const_iterator(_Base::begin(), this); }
 274
 275       const_iterator
 276       cend() const noexcept
 277       { return const_iterator(_Base::end(), this); }
 278
 279       const_reverse_iterator
 280       crbegin() const noexcept
 281       { return const_reverse_iterator(end()); }
 282
 283       const_reverse_iterator
 284       crend() const noexcept
 285       { return const_reverse_iterator(begin()); }
 286 #endif
 287
 288       // 21.3.3 capacity:
 289       using _Base::size;
 290       using _Base::length;
 291       using _Base::max_size;
 292
 293       void
 294       resize(size_type __n, _CharT __c)
 295       {
 296         _Base::resize(__n, __c);
 297         this->_M_invalidate_all();
 298       }
 299
 300       void
 301       resize(size_type __n)
 302       { this->resize(__n, _CharT()); }
 303
 304 #if __cplusplus >= 201103L
 305       void
 306       shrink_to_fit() noexcept
 307       {
 308         if (capacity() > size())
 309           {
 310             __try
 311               {
 312                 reserve(0);
 313                 this->_M_invalidate_all();
 314               }
 315             __catch(...)
 316               { }
 317           }
 318       }
 319 #endif
 320
 321       using _Base::capacity;
 322       using _Base::reserve;
 323
 324       void
 325       clear() // _GLIBCXX_NOEXCEPT
 326       {
 327         _Base::clear();
 328         this->_M_invalidate_all();
 329       }
 330
 331       using _Base::empty;
 332
 333       // 21.3.4 element access:
 334       const_reference
 335       operator[](size_type __pos) const _GLIBCXX_NOEXCEPT
 336       {
 337         _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
 338                               _M_message(__gnu_debug::__msg_subscript_oob)
 339                               ._M_sequence(*this, "this")
 340                               ._M_integer(__pos, "__pos")
 341                               ._M_integer(this->size(), "size"));
 342         return _M_base()[__pos];
 343       }
 344
 345       reference
 346       operator[](size_type __pos) // _GLIBCXX_NOEXCEPT
 347       {
 348 #if __cplusplus < 201103L && defined(_GLIBCXX_DEBUG_PEDANTIC)
 349         __glibcxx_check_subscript(__pos);
 350 #else
 351         // as an extension v3 allows s[s.size()] when s is non-const.
 352         _GLIBCXX_DEBUG_VERIFY(__pos <= this->size(),
 353                               _M_message(__gnu_debug::__msg_subscript_oob)
 354                               ._M_sequence(*this, "this")
 355                               ._M_integer(__pos, "__pos")
 356                               ._M_integer(this->size(), "size"));
 357 #endif
 358         return _M_base()[__pos];
 359       }
 360
 361       using _Base::at;
 362
 363 #if __cplusplus >= 201103L
 364       using _Base::front;
 365       using _Base::back;
 366 #endif
 367
 368       // 21.3.5 modifiers:
 369       basic_string&
 370       operator+=(const basic_string& __str)
 371       {
 372         _M_base() += __str;
 373         this->_M_invalidate_all();
 374         return *this;
 375       }
 376
 377       basic_string&
 378       operator+=(const _CharT* __s)
 379       {
 380         __glibcxx_check_string(__s);
 381         _M_base() += __s;
 382         this->_M_invalidate_all();
 383         return *this;
 384       }
 385
 386       basic_string&
 387       operator+=(_CharT __c)
 388       {
 389         _M_base() += __c;
 390         this->_M_invalidate_all();
 391         return *this;
 392       }
 393
 394 #if __cplusplus >= 201103L
 395       basic_string&
 396       operator+=(std::initializer_list<_CharT> __l)
 397       {
 398         _M_base() += __l;
 399         this->_M_invalidate_all();
 400         return *this;
 401       }
 402 #endif // C++11
 403
 404       basic_string&
 405       append(const basic_string& __str)
 406       {
 407         _Base::append(__str);
 408         this->_M_invalidate_all();
 409         return *this;
 410       }
 411
 412       basic_string&
 413       append(const basic_string& __str, size_type __pos, size_type __n)
 414       {
 415         _Base::append(__str, __pos, __n);
 416         this->_M_invalidate_all();
 417         return *this;
 418       }
 419
 420       basic_string&
 421       append(const _CharT* __s, size_type __n)
 422       {
 423         __glibcxx_check_string_len(__s, __n);
 424         _Base::append(__s, __n);
 425         this->_M_invalidate_all();
 426         return *this;
 427       }
 428
 429       basic_string&
 430       append(const _CharT* __s)
 431       {
 432         __glibcxx_check_string(__s);
 433         _Base::append(__s);
 434         this->_M_invalidate_all();
 435         return *this;
 436       }
 437
 438       basic_string&
 439       append(size_type __n, _CharT __c)
 440       {
 441         _Base::append(__n, __c);
 442         this->_M_invalidate_all();
 443         return *this;
 444       }
 445
 446       template<typename _InputIterator>
 447         basic_string&
 448         append(_InputIterator __first, _InputIterator __last)
 449         {
 450           typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
 451           __glibcxx_check_valid_range2(__first, __last, __dist);
 452
 453           if (__dist.second >= __dp_sign)
 454             _Base::append(__gnu_debug::__unsafe(__first),
 455                           __gnu_debug::__unsafe(__last));
 456           else
 457             _Base::append(__first, __last);
 458
 459           this->_M_invalidate_all();
 460           return *this;
 461         }
 462
 463       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 464       // 7. string clause minor problems
 465       void
 466       push_back(_CharT __c)
 467       {
 468         _Base::push_back(__c);
 469         this->_M_invalidate_all();
 470       }
 471
 472       basic_string&
 473       assign(const basic_string& __x)
 474       {
 475         _Base::assign(__x);
 476         this->_M_invalidate_all();
 477         return *this;
 478       }
 479
 480 #if __cplusplus >= 201103L
 481       basic_string&
 482       assign(basic_string&& __x)
 483       noexcept(noexcept(std::declval<_Base&>().assign(std::move(__x))))
 484       {
 485         _Base::assign(std::move(__x));
 486         this->_M_invalidate_all();
 487         return *this;
 488       }
 489 #endif // C++11
 490
 491       basic_string&
 492       assign(const basic_string& __str, size_type __pos, size_type __n)
 493       {
 494         _Base::assign(__str, __pos, __n);
 495         this->_M_invalidate_all();
 496         return *this;
 497       }
 498
 499       basic_string&
 500       assign(const _CharT* __s, size_type __n)
 501       {
 502         __glibcxx_check_string_len(__s, __n);
 503         _Base::assign(__s, __n);
 504         this->_M_invalidate_all();
 505         return *this;
 506       }
 507
 508       basic_string&
 509       assign(const _CharT* __s)
 510       {
 511         __glibcxx_check_string(__s);
 512         _Base::assign(__s);
 513         this->_M_invalidate_all();
 514         return *this;
 515       }
 516
 517       basic_string&
 518       assign(size_type __n, _CharT __c)
 519       {
 520         _Base::assign(__n, __c);
 521         this->_M_invalidate_all();
 522         return *this;
 523       }
 524
 525       template<typename _InputIterator>
 526         basic_string&
 527         assign(_InputIterator __first, _InputIterator __last)
 528         {
 529           typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
 530           __glibcxx_check_valid_range2(__first, __last, __dist);
 531
 532           if (__dist.second >= __dp_sign)
 533             _Base::assign(__gnu_debug::__unsafe(__first),
 534                           __gnu_debug::__unsafe(__last));
 535           else
 536             _Base::assign(__first, __last);
 537
 538           this->_M_invalidate_all();
 539           return *this;
 540         }
 541
 542 #if __cplusplus >= 201103L
 543       basic_string&
 544       assign(std::initializer_list<_CharT> __l)
 545       {
 546         _Base::assign(__l);
 547         this->_M_invalidate_all();
 548         return *this;
 549       }
 550 #endif // C++11
 551
 552       basic_string&
 553       insert(size_type __pos1, const basic_string& __str)
 554       {
 555         _Base::insert(__pos1, __str);
 556         this->_M_invalidate_all();
 557         return *this;
 558       }
 559
 560       basic_string&
 561       insert(size_type __pos1, const basic_string& __str,
 562              size_type __pos2, size_type __n)
 563       {
 564         _Base::insert(__pos1, __str, __pos2, __n);
 565         this->_M_invalidate_all();
 566         return *this;
 567       }
 568
 569       basic_string&
 570       insert(size_type __pos, const _CharT* __s, size_type __n)
 571       {
 572         __glibcxx_check_string(__s);
 573         _Base::insert(__pos, __s, __n);
 574         this->_M_invalidate_all();
 575         return *this;
 576       }
 577
 578       basic_string&
 579       insert(size_type __pos, const _CharT* __s)
 580       {
 581         __glibcxx_check_string(__s);
 582         _Base::insert(__pos, __s);
 583         this->_M_invalidate_all();
 584         return *this;
 585       }
 586
 587       basic_string&
 588       insert(size_type __pos, size_type __n, _CharT __c)
 589       {
 590         _Base::insert(__pos, __n, __c);
 591         this->_M_invalidate_all();
 592         return *this;
 593       }
 594
 595       iterator
 596       insert(__const_iterator __p, _CharT __c)
 597       {
 598         __glibcxx_check_insert(__p);
 599         typename _Base::iterator __res = _Base::insert(__p.base(), __c);
 600         this->_M_invalidate_all();
 601         return iterator(__res, this);
 602       }
 603
 604 #if __cplusplus >= 201103L
 605       iterator
 606       insert(const_iterator __p, size_type __n, _CharT __c)
 607       {
 608         __glibcxx_check_insert(__p);
 609 #if _GLIBCXX_USE_CXX11_ABI
 610         typename _Base::iterator __res = _Base::insert(__p.base(), __n, __c);
 611 #else
 612         const size_type __offset = __p.base() - _Base::cbegin();
 613         _Base::insert(_Base::begin() + __offset, __n, __c);
 614         typename _Base::iterator __res = _Base::begin() + __offset;
 615 #endif
 616         this->_M_invalidate_all();
 617         return iterator(__res, this);
 618       }
 619 #else
 620       void
 621       insert(iterator __p, size_type __n, _CharT __c)
 622       {
 623         __glibcxx_check_insert(__p);
 624         _Base::insert(__p.base(), __n, __c);
 625         this->_M_invalidate_all();
 626       }
 627 #endif
 628
 629       template<typename _InputIterator>
 630         iterator
 631         insert(__const_iterator __p,
 632                _InputIterator __first, _InputIterator __last)
 633         {
 634           typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
 635           __glibcxx_check_insert_range(__p, __first, __last, __dist);
 636
 637           typename _Base::iterator __res;
 638 #if _GLIBCXX_USE_CXX11_ABI
 639           if (__dist.second >= __dp_sign)
 640             __res = _Base::insert(__p.base(), __gnu_debug::__unsafe(__first),
 641                                   __gnu_debug::__unsafe(__last));
 642           else
 643             __res = _Base::insert(__p.base(), __first, __last);
 644 #else
 645           const size_type __offset = __p.base() - _Base::begin();
 646           _Base::insert(__p.base(), __first, __last);
 647           __res = _Base::begin() + __offset;
 648 #endif
 649           this->_M_invalidate_all();
 650           return iterator(__res, this);
 651         }
 652
 653 #if __cplusplus >= 201103L
 654       iterator
 655       insert(const_iterator __p, std::initializer_list<_CharT> __l)
 656       {
 657         __glibcxx_check_insert(__p);
 658 #if _GLIBCXX_USE_CXX11_ABI
 659         const auto __res = _Base::insert(__p.base(), __l);
 660 #else
 661         const size_type __offset = __p.base() - _Base::cbegin();
 662         _Base::insert(_Base::begin() + __offset, __l);
 663         auto __res = _Base::begin() + __offset;
 664 #endif
 665         this->_M_invalidate_all();
 666         return iterator(__res, this);
 667       }
 668 #endif // C++11
 669
 670       basic_string&
 671       erase(size_type __pos = 0, size_type __n = _Base::npos)
 672       {
 673         _Base::erase(__pos, __n);
 674         this->_M_invalidate_all();
 675         return *this;
 676       }
 677
 678       iterator
 679       erase(iterator __position)
 680       {
 681         __glibcxx_check_erase(__position);
 682         typename _Base::iterator __res = _Base::erase(__position.base());
 683         this->_M_invalidate_all();
 684         return iterator(__res, this);
 685       }
 686
 687       iterator
 688       erase(iterator __first, iterator __last)
 689       {
 690         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 691         // 151. can't currently clear() empty container
 692         __glibcxx_check_erase_range(__first, __last);
 693         typename _Base::iterator __res = _Base::erase(__first.base(),
 694                                                       __last.base());
 695         this->_M_invalidate_all();
 696         return iterator(__res, this);
 697       }
 698
 699 #if __cplusplus >= 201103L
 700       void
 701       pop_back() // noexcept
 702       {
 703         __glibcxx_check_nonempty();
 704         _Base::pop_back();
 705         this->_M_invalidate_all();
 706       }
 707 #endif // C++11
 708
 709       basic_string&
 710       replace(size_type __pos1, size_type __n1, const basic_string& __str)
 711       {
 712         _Base::replace(__pos1, __n1, __str);
 713         this->_M_invalidate_all();
 714         return *this;
 715       }
 716
 717       basic_string&
 718       replace(size_type __pos1, size_type __n1, const basic_string& __str,
 719               size_type __pos2, size_type __n2)
 720       {
 721         _Base::replace(__pos1, __n1, __str, __pos2, __n2);
 722         this->_M_invalidate_all();
 723         return *this;
 724       }
 725
 726       basic_string&
 727       replace(size_type __pos, size_type __n1, const _CharT* __s,
 728               size_type __n2)
 729       {
 730         __glibcxx_check_string_len(__s, __n2);
 731         _Base::replace(__pos, __n1, __s, __n2);
 732         this->_M_invalidate_all();
 733         return *this;
 734       }
 735
 736       basic_string&
 737       replace(size_type __pos, size_type __n1, const _CharT* __s)
 738       {
 739         __glibcxx_check_string(__s);
 740         _Base::replace(__pos, __n1, __s);
 741         this->_M_invalidate_all();
 742         return *this;
 743       }
 744
 745       basic_string&
 746       replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
 747       {
 748         _Base::replace(__pos, __n1, __n2, __c);
 749         this->_M_invalidate_all();
 750         return *this;
 751       }
 752
 753       basic_string&
 754       replace(__const_iterator __i1, __const_iterator __i2,
 755               const basic_string& __str)
 756       {
 757         __glibcxx_check_erase_range(__i1, __i2);
 758         _Base::replace(__i1.base(), __i2.base(), __str);
 759         this->_M_invalidate_all();
 760         return *this;
 761       }
 762
 763       basic_string&
 764       replace(__const_iterator __i1, __const_iterator __i2,
 765               const _CharT* __s, size_type __n)
 766       {
 767         __glibcxx_check_erase_range(__i1, __i2);
 768         __glibcxx_check_string_len(__s, __n);
 769         _Base::replace(__i1.base(), __i2.base(), __s, __n);
 770         this->_M_invalidate_all();
 771         return *this;
 772       }
 773
 774       basic_string&
 775       replace(__const_iterator __i1, __const_iterator __i2,
 776               const _CharT* __s)
 777       {
 778         __glibcxx_check_erase_range(__i1, __i2);
 779         __glibcxx_check_string(__s);
 780         _Base::replace(__i1.base(), __i2.base(), __s);
 781         this->_M_invalidate_all();
 782         return *this;
 783       }
 784
 785       basic_string&
 786       replace(__const_iterator __i1, __const_iterator __i2,
 787               size_type __n, _CharT __c)
 788       {
 789         __glibcxx_check_erase_range(__i1, __i2);
 790         _Base::replace(__i1.base(), __i2.base(), __n, __c);
 791         this->_M_invalidate_all();
 792         return *this;
 793       }
 794
 795       template<typename _InputIterator>
 796         basic_string&
 797         replace(__const_iterator __i1, __const_iterator __i2,
 798                 _InputIterator __j1, _InputIterator __j2)
 799         {
 800           __glibcxx_check_erase_range(__i1, __i2);
 801
 802           typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
 803           __glibcxx_check_valid_range2(__j1, __j2, __dist);
 804
 805           if (__dist.second >= __dp_sign)
 806             _Base::replace(__i1.base(), __i2.base(),
 807                            __gnu_debug::__unsafe(__j1),
 808                            __gnu_debug::__unsafe(__j2));
 809           else
 810             _Base::replace(__i1.base(), __i2.base(), __j1, __j2);
 811
 812           this->_M_invalidate_all();
 813           return *this;
 814         }
 815
 816 #if __cplusplus >= 201103L
 817       basic_string&
 818       replace(__const_iterator __i1, __const_iterator __i2,
 819               std::initializer_list<_CharT> __l)
 820       {
 821         __glibcxx_check_erase_range(__i1, __i2);
 822         _Base::replace(__i1.base(), __i2.base(), __l);
 823         this->_M_invalidate_all();
 824         return *this;
 825       }
 826 #endif // C++11
 827
 828       size_type
 829       copy(_CharT* __s, size_type __n, size_type __pos = 0) const
 830       {
 831         __glibcxx_check_string_len(__s, __n);
 832         return _Base::copy(__s, __n, __pos);
 833       }
 834
 835       void
 836       swap(basic_string& __x)
 837         _GLIBCXX_NOEXCEPT_IF(std::__is_nothrow_swappable<_Base>::value)
 838       {
 839         _Safe::_M_swap(__x);
 840         _Base::swap(__x);
 841       }
 842
 843       // 21.3.6 string operations:
 844       const _CharT*
 845       c_str() const _GLIBCXX_NOEXCEPT
 846       {
 847         const _CharT* __res = _Base::c_str();
 848         this->_M_invalidate_all();
 849         return __res;
 850       }
 851
 852       const _CharT*
 853       data() const _GLIBCXX_NOEXCEPT
 854       {
 855         const _CharT* __res = _Base::data();
 856         this->_M_invalidate_all();
 857         return __res;
 858       }
 859
 860       using _Base::get_allocator;
 861
 862       size_type
 863       find(const basic_string& __str, size_type __pos = 0) const
 864         _GLIBCXX_NOEXCEPT
 865       { return _Base::find(__str, __pos); }
 866
 867       size_type
 868       find(const _CharT* __s, size_type __pos, size_type __n) const
 869       {
 870         __glibcxx_check_string(__s);
 871         return _Base::find(__s, __pos, __n);
 872       }
 873
 874       size_type
 875       find(const _CharT* __s, size_type __pos = 0) const
 876       {
 877         __glibcxx_check_string(__s);
 878         return _Base::find(__s, __pos);
 879       }
 880
 881       size_type
 882       find(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
 883       { return _Base::find(__c, __pos); }
 884
 885       size_type
 886       rfind(const basic_string& __str, size_type __pos = _Base::npos) const
 887         _GLIBCXX_NOEXCEPT
 888       { return _Base::rfind(__str, __pos); }
 889
 890       size_type
 891       rfind(const _CharT* __s, size_type __pos, size_type __n) const
 892       {
 893         __glibcxx_check_string_len(__s, __n);
 894         return _Base::rfind(__s, __pos, __n);
 895       }
 896
 897       size_type
 898       rfind(const _CharT* __s, size_type __pos = _Base::npos) const
 899       {
 900         __glibcxx_check_string(__s);
 901         return _Base::rfind(__s, __pos);
 902       }
 903
 904       size_type
 905       rfind(_CharT __c, size_type __pos = _Base::npos) const _GLIBCXX_NOEXCEPT
 906       { return _Base::rfind(__c, __pos); }
 907
 908       size_type
 909       find_first_of(const basic_string& __str, size_type __pos = 0) const
 910         _GLIBCXX_NOEXCEPT
 911       { return _Base::find_first_of(__str, __pos); }
 912
 913       size_type
 914       find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
 915       {
 916         __glibcxx_check_string(__s);
 917         return _Base::find_first_of(__s, __pos, __n);
 918       }
 919
 920       size_type
 921       find_first_of(const _CharT* __s, size_type __pos = 0) const
 922       {
 923         __glibcxx_check_string(__s);
 924         return _Base::find_first_of(__s, __pos);
 925       }
 926
 927       size_type
 928       find_first_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
 929       { return _Base::find_first_of(__c, __pos); }
 930
 931       size_type
 932       find_last_of(const basic_string& __str,
 933                    size_type __pos = _Base::npos) const _GLIBCXX_NOEXCEPT
 934       { return _Base::find_last_of(__str, __pos); }
 935
 936       size_type
 937       find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
 938       {
 939         __glibcxx_check_string(__s);
 940         return _Base::find_last_of(__s, __pos, __n);
 941       }
 942
 943       size_type
 944       find_last_of(const _CharT* __s, size_type __pos = _Base::npos) const
 945       {
 946         __glibcxx_check_string(__s);
 947         return _Base::find_last_of(__s, __pos);
 948       }
 949
 950       size_type
 951       find_last_of(_CharT __c, size_type __pos = _Base::npos) const
 952         _GLIBCXX_NOEXCEPT
 953       { return _Base::find_last_of(__c, __pos); }
 954
 955       size_type
 956       find_first_not_of(const basic_string& __str, size_type __pos = 0) const
 957         _GLIBCXX_NOEXCEPT
 958       { return _Base::find_first_not_of(__str, __pos); }
 959
 960       size_type
 961       find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
 962       {
 963         __glibcxx_check_string_len(__s, __n);
 964         return _Base::find_first_not_of(__s, __pos, __n);
 965       }
 966
 967       size_type
 968       find_first_not_of(const _CharT* __s, size_type __pos = 0) const
 969       {
 970         __glibcxx_check_string(__s);
 971         return _Base::find_first_not_of(__s, __pos);
 972       }
 973
 974       size_type
 975       find_first_not_of(_CharT __c, size_type __pos = 0) const _GLIBCXX_NOEXCEPT
 976       { return _Base::find_first_not_of(__c, __pos); }
 977
 978       size_type
 979       find_last_not_of(const basic_string& __str,
 980                        size_type __pos = _Base::npos) const
 981         _GLIBCXX_NOEXCEPT
 982       { return _Base::find_last_not_of(__str, __pos); }
 983
 984       size_type
 985       find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
 986       {
 987         __glibcxx_check_string(__s);
 988         return _Base::find_last_not_of(__s, __pos, __n);
 989       }
 990
 991       size_type
 992       find_last_not_of(const _CharT* __s, size_type __pos = _Base::npos) const
 993       {
 994         __glibcxx_check_string(__s);
 995         return _Base::find_last_not_of(__s, __pos);
 996       }
 997
 998       size_type
 999       find_last_not_of(_CharT __c, size_type __pos = _Base::npos) const
1000         _GLIBCXX_NOEXCEPT
1001       { return _Base::find_last_not_of(__c, __pos); }
1002
1003       basic_string
1004       substr(size_type __pos = 0, size_type __n = _Base::npos) const
1005       { return basic_string(_Base::substr(__pos, __n)); }
1006
1007       int
1008       compare(const basic_string& __str) const
1009       { return _Base::compare(__str); }
1010
1011       int
1012       compare(size_type __pos1, size_type __n1,
1013               const basic_string& __str) const
1014       { return _Base::compare(__pos1, __n1, __str); }
1015
1016       int
1017       compare(size_type __pos1, size_type __n1, const basic_string& __str,
1018               size_type __pos2, size_type __n2) const
1019       { return _Base::compare(__pos1, __n1, __str, __pos2, __n2); }
1020
1021       int
1022       compare(const _CharT* __s) const
1023       {
1024         __glibcxx_check_string(__s);
1025         return _Base::compare(__s);
1026       }
1027
1028       //  _GLIBCXX_RESOLVE_LIB_DEFECTS
1029       //  5. string::compare specification questionable
1030       int
1031       compare(size_type __pos1, size_type __n1, const _CharT* __s) const
1032       {
1033         __glibcxx_check_string(__s);
1034         return _Base::compare(__pos1, __n1, __s);
1035       }
1036
1037       //  _GLIBCXX_RESOLVE_LIB_DEFECTS
1038       //  5. string::compare specification questionable
1039       int
1040       compare(size_type __pos1, size_type __n1,const _CharT* __s,
1041               size_type __n2) const
1042       {
1043         __glibcxx_check_string_len(__s, __n2);
1044         return _Base::compare(__pos1, __n1, __s, __n2);
1045       }
1046
1047       _Base&
1048       _M_base() _GLIBCXX_NOEXCEPT               { return *this; }
1049
1050       const _Base&
1051       _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
1052
1053       using _Safe::_M_invalidate_all;
1054     };
1055
1056   template<typename _CharT, typename _Traits, typename _Allocator>
1057     inline basic_string<_CharT,_Traits,_Allocator>
1058     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1059               const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1060     { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
1061
1062   template<typename _CharT, typename _Traits, typename _Allocator>
1063     inline basic_string<_CharT,_Traits,_Allocator>
1064     operator+(const _CharT* __lhs,
1065               const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1066     {
1067       __glibcxx_check_string(__lhs);
1068       return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
1069     }
1070
1071   template<typename _CharT, typename _Traits, typename _Allocator>
1072     inline basic_string<_CharT,_Traits,_Allocator>
1073     operator+(_CharT __lhs,
1074               const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1075     { return basic_string<_CharT,_Traits,_Allocator>(1, __lhs) += __rhs; }
1076
1077   template<typename _CharT, typename _Traits, typename _Allocator>
1078     inline basic_string<_CharT,_Traits,_Allocator>
1079     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1080               const _CharT* __rhs)
1081     {
1082       __glibcxx_check_string(__rhs);
1083       return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs;
1084     }
1085
1086   template<typename _CharT, typename _Traits, typename _Allocator>
1087     inline basic_string<_CharT,_Traits,_Allocator>
1088     operator+(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1089               _CharT __rhs)
1090     { return basic_string<_CharT,_Traits,_Allocator>(__lhs) += __rhs; }
1091
1092   template<typename _CharT, typename _Traits, typename _Allocator>
1093     inline bool
1094     operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1095                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1096     { return __lhs._M_base() == __rhs._M_base(); }
1097
1098   template<typename _CharT, typename _Traits, typename _Allocator>
1099     inline bool
1100     operator==(const _CharT* __lhs,
1101                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1102     {
1103       __glibcxx_check_string(__lhs);
1104       return __lhs == __rhs._M_base();
1105     }
1106
1107   template<typename _CharT, typename _Traits, typename _Allocator>
1108     inline bool
1109     operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1110                const _CharT* __rhs)
1111     {
1112       __glibcxx_check_string(__rhs);
1113       return __lhs._M_base() == __rhs;
1114     }
1115
1116   template<typename _CharT, typename _Traits, typename _Allocator>
1117     inline bool
1118     operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1119                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1120     { return __lhs._M_base() != __rhs._M_base(); }
1121
1122   template<typename _CharT, typename _Traits, typename _Allocator>
1123     inline bool
1124     operator!=(const _CharT* __lhs,
1125                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1126     {
1127       __glibcxx_check_string(__lhs);
1128       return __lhs != __rhs._M_base();
1129     }
1130
1131   template<typename _CharT, typename _Traits, typename _Allocator>
1132     inline bool
1133     operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1134                const _CharT* __rhs)
1135     {
1136       __glibcxx_check_string(__rhs);
1137       return __lhs._M_base() != __rhs;
1138     }
1139
1140   template<typename _CharT, typename _Traits, typename _Allocator>
1141     inline bool
1142     operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1143               const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1144     { return __lhs._M_base() < __rhs._M_base(); }
1145
1146   template<typename _CharT, typename _Traits, typename _Allocator>
1147     inline bool
1148     operator<(const _CharT* __lhs,
1149               const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1150     {
1151       __glibcxx_check_string(__lhs);
1152       return __lhs < __rhs._M_base();
1153     }
1154
1155   template<typename _CharT, typename _Traits, typename _Allocator>
1156     inline bool
1157     operator<(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1158               const _CharT* __rhs)
1159     {
1160       __glibcxx_check_string(__rhs);
1161       return __lhs._M_base() < __rhs;
1162     }
1163
1164   template<typename _CharT, typename _Traits, typename _Allocator>
1165     inline bool
1166     operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1167                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1168     { return __lhs._M_base() <= __rhs._M_base(); }
1169
1170   template<typename _CharT, typename _Traits, typename _Allocator>
1171     inline bool
1172     operator<=(const _CharT* __lhs,
1173                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1174     {
1175       __glibcxx_check_string(__lhs);
1176       return __lhs <= __rhs._M_base();
1177     }
1178
1179   template<typename _CharT, typename _Traits, typename _Allocator>
1180     inline bool
1181     operator<=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1182                const _CharT* __rhs)
1183     {
1184       __glibcxx_check_string(__rhs);
1185       return __lhs._M_base() <= __rhs;
1186     }
1187
1188   template<typename _CharT, typename _Traits, typename _Allocator>
1189     inline bool
1190     operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1191                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1192     { return __lhs._M_base() >= __rhs._M_base(); }
1193
1194   template<typename _CharT, typename _Traits, typename _Allocator>
1195     inline bool
1196     operator>=(const _CharT* __lhs,
1197                const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1198     {
1199       __glibcxx_check_string(__lhs);
1200       return __lhs >= __rhs._M_base();
1201     }
1202
1203   template<typename _CharT, typename _Traits, typename _Allocator>
1204     inline bool
1205     operator>=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1206                const _CharT* __rhs)
1207     {
1208       __glibcxx_check_string(__rhs);
1209       return __lhs._M_base() >= __rhs;
1210     }
1211
1212   template<typename _CharT, typename _Traits, typename _Allocator>
1213     inline bool
1214     operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1215               const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1216     { return __lhs._M_base() > __rhs._M_base(); }
1217
1218   template<typename _CharT, typename _Traits, typename _Allocator>
1219     inline bool
1220     operator>(const _CharT* __lhs,
1221               const basic_string<_CharT,_Traits,_Allocator>& __rhs)
1222     {
1223       __glibcxx_check_string(__lhs);
1224       return __lhs > __rhs._M_base();
1225     }
1226
1227   template<typename _CharT, typename _Traits, typename _Allocator>
1228     inline bool
1229     operator>(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
1230               const _CharT* __rhs)
1231     {
1232       __glibcxx_check_string(__rhs);
1233       return __lhs._M_base() > __rhs;
1234     }
1235
1236   // 21.3.7.8:
1237   template<typename _CharT, typename _Traits, typename _Allocator>
1238     inline void
1239     swap(basic_string<_CharT,_Traits,_Allocator>& __lhs,
1240          basic_string<_CharT,_Traits,_Allocator>& __rhs)
1241     { __lhs.swap(__rhs); }
1242
1243   template<typename _CharT, typename _Traits, typename _Allocator>
1244     std::basic_ostream<_CharT, _Traits>&
1245     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1246                const basic_string<_CharT, _Traits, _Allocator>& __str)
1247     { return __os << __str._M_base(); }
1248
1249   template<typename _CharT, typename _Traits, typename _Allocator>
1250     std::basic_istream<_CharT,_Traits>&
1251     operator>>(std::basic_istream<_CharT,_Traits>& __is,
1252                basic_string<_CharT,_Traits,_Allocator>& __str)
1253     {
1254       std::basic_istream<_CharT,_Traits>& __res = __is >> __str._M_base();
1255       __str._M_invalidate_all();
1256       return __res;
1257     }
1258
1259   template<typename _CharT, typename _Traits, typename _Allocator>
1260     std::basic_istream<_CharT,_Traits>&
1261     getline(std::basic_istream<_CharT,_Traits>& __is,
1262             basic_string<_CharT,_Traits,_Allocator>& __str, _CharT __delim)
1263     {
1264       std::basic_istream<_CharT,_Traits>& __res = getline(__is,
1265                                                           __str._M_base(),
1266                                                         __delim);
1267       __str._M_invalidate_all();
1268       return __res;
1269     }
1270
1271   template<typename _CharT, typename _Traits, typename _Allocator>
1272     std::basic_istream<_CharT,_Traits>&
1273     getline(std::basic_istream<_CharT,_Traits>& __is,
1274             basic_string<_CharT,_Traits,_Allocator>& __str)
1275     {
1276       std::basic_istream<_CharT,_Traits>& __res = getline(__is,
1277                                                           __str._M_base());
1278       __str._M_invalidate_all();
1279       return __res;
1280     }
1281
1282   typedef basic_string<char>    string;
1283
1284 #ifdef _GLIBCXX_USE_WCHAR_T
1285   typedef basic_string<wchar_t> wstring;
1286 #endif
1287
1288   template<typename _CharT, typename _Traits, typename _Allocator>
1289     struct _Insert_range_from_self_is_safe<
1290       __gnu_debug::basic_string<_CharT, _Traits, _Allocator> >
1291       { enum { __value = 1 }; };
1292
1293 } // namespace __gnu_debug
1294
1295 #endif