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 44namespace __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 && __cplusplus >= 201103 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 1296