1 // -*- C++ -*- 2 //===-------------------------- ostream -----------------------------------===// 3 // 4 // The LLVM Compiler Infrastructure 5 // 6 // This file is dual licensed under the MIT and the University of Illinois Open 7 // Source Licenses. See LICENSE.TXT for details. 8 // 9 //===----------------------------------------------------------------------===// 10 11 #ifndef _LIBCPP_OSTREAM 12 #define _LIBCPP_OSTREAM 13 14 /* 15 ostream synopsis 16 17 template <class charT, class traits = char_traits<charT> > 18 class basic_ostream 19 : virtual public basic_ios<charT,traits> 20 { 21 public: 22 // types (inherited from basic_ios (27.5.4)): 23 typedef charT char_type; 24 typedef traits traits_type; 25 typedef typename traits_type::int_type int_type; 26 typedef typename traits_type::pos_type pos_type; 27 typedef typename traits_type::off_type off_type; 28 29 // 27.7.2.2 Constructor/destructor: 30 explicit basic_ostream(basic_streambuf<char_type,traits>* sb); 31 basic_ostream(basic_ostream&& rhs); 32 virtual ~basic_ostream(); 33 34 // 27.7.2.3 Assign/swap 35 basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14 36 basic_ostream& operator=(basic_ostream&& rhs); 37 void swap(basic_ostream& rhs); 38 39 // 27.7.2.4 Prefix/suffix: 40 class sentry; 41 42 // 27.7.2.6 Formatted output: 43 basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&)); 44 basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&)); 45 basic_ostream& operator<<(ios_base& (*pf)(ios_base&)); 46 basic_ostream& operator<<(bool n); 47 basic_ostream& operator<<(short n); 48 basic_ostream& operator<<(unsigned short n); 49 basic_ostream& operator<<(int n); 50 basic_ostream& operator<<(unsigned int n); 51 basic_ostream& operator<<(long n); 52 basic_ostream& operator<<(unsigned long n); 53 basic_ostream& operator<<(long long n); 54 basic_ostream& operator<<(unsigned long long n); 55 basic_ostream& operator<<(float f); 56 basic_ostream& operator<<(double f); 57 basic_ostream& operator<<(long double f); 58 basic_ostream& operator<<(const void* p); 59 basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb); 60 61 // 27.7.2.7 Unformatted output: 62 basic_ostream& put(char_type c); 63 basic_ostream& write(const char_type* s, streamsize n); 64 basic_ostream& flush(); 65 66 // 27.7.2.5 seeks: 67 pos_type tellp(); 68 basic_ostream& seekp(pos_type); 69 basic_ostream& seekp(off_type, ios_base::seekdir); 70 protected: 71 basic_ostream(const basic_ostream& rhs) = delete; 72 basic_ostream(basic_ostream&& rhs); 73 // 27.7.3.3 Assign/swap 74 basic_ostream& operator=(basic_ostream& rhs) = delete; 75 basic_ostream& operator=(const basic_ostream&& rhs); 76 void swap(basic_ostream& rhs); 77 }; 78 79 // 27.7.2.6.4 character inserters 80 81 template<class charT, class traits> 82 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT); 83 84 template<class charT, class traits> 85 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char); 86 87 template<class traits> 88 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char); 89 90 // signed and unsigned 91 92 template<class traits> 93 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char); 94 95 template<class traits> 96 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char); 97 98 // NTBS 99 template<class charT, class traits> 100 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*); 101 102 template<class charT, class traits> 103 basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*); 104 105 template<class traits> 106 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*); 107 108 // signed and unsigned 109 template<class traits> 110 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*); 111 112 template<class traits> 113 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*); 114 115 // swap: 116 template <class charT, class traits> 117 void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y); 118 119 template <class charT, class traits> 120 basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os); 121 122 template <class charT, class traits> 123 basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os); 124 125 template <class charT, class traits> 126 basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os); 127 128 // rvalue stream insertion 129 template <class charT, class traits, class T> 130 basic_ostream<charT, traits>& 131 operator<<(basic_ostream<charT, traits>&& os, const T& x); 132 133 } // std 134 135 */ 136 137 #include <__config> 138 #include <ios> 139 #include <streambuf> 140 #include <locale> 141 #include <iterator> 142 #include <bitset> 143 #include <version> 144 145 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 146 #pragma GCC system_header 147 #endif 148 149 _LIBCPP_BEGIN_NAMESPACE_STD 150 151 template <class _CharT, class _Traits> 152 class _LIBCPP_TEMPLATE_VIS basic_ostream 153 : virtual public basic_ios<_CharT, _Traits> 154 { 155 public: 156 // types (inherited from basic_ios (27.5.4)): 157 typedef _CharT char_type; 158 typedef _Traits traits_type; 159 typedef typename traits_type::int_type int_type; 160 typedef typename traits_type::pos_type pos_type; 161 typedef typename traits_type::off_type off_type; 162 163 // 27.7.2.2 Constructor/destructor: 164 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 165 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) 166 { this->init(__sb); } 167 virtual ~basic_ostream(); 168 protected: 169 #ifndef _LIBCPP_CXX03_LANG 170 inline _LIBCPP_INLINE_VISIBILITY 171 basic_ostream(basic_ostream&& __rhs); 172 173 // 27.7.2.3 Assign/swap 174 inline _LIBCPP_INLINE_VISIBILITY 175 basic_ostream& operator=(basic_ostream&& __rhs); 176 #endif 177 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 178 void swap(basic_ostream& __rhs) 179 { basic_ios<char_type, traits_type>::swap(__rhs); } 180 181 #ifndef _LIBCPP_CXX03_LANG 182 basic_ostream (const basic_ostream& __rhs) = delete; 183 basic_ostream& operator=(const basic_ostream& __rhs) = delete; 184 #else 185 basic_ostream (const basic_ostream& __rhs); // not defined 186 basic_ostream& operator=(const basic_ostream& __rhs); // not defined 187 #endif 188 public: 189 190 // 27.7.2.4 Prefix/suffix: 191 class _LIBCPP_TEMPLATE_VIS sentry; 192 193 // 27.7.2.6 Formatted output: 194 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 195 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) 196 { return __pf(*this); } 197 198 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 199 basic_ostream& operator<<(basic_ios<char_type, traits_type>& 200 (*__pf)(basic_ios<char_type,traits_type>&)) 201 { __pf(*this); return *this; } 202 203 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 204 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) 205 { __pf(*this); return *this; } 206 207 basic_ostream& operator<<(bool __n); 208 basic_ostream& operator<<(short __n); 209 basic_ostream& operator<<(unsigned short __n); 210 basic_ostream& operator<<(int __n); 211 basic_ostream& operator<<(unsigned int __n); 212 basic_ostream& operator<<(long __n); 213 basic_ostream& operator<<(unsigned long __n); 214 basic_ostream& operator<<(long long __n); 215 basic_ostream& operator<<(unsigned long long __n); 216 basic_ostream& operator<<(float __f); 217 basic_ostream& operator<<(double __f); 218 basic_ostream& operator<<(long double __f); 219 basic_ostream& operator<<(const void* __p); 220 basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb); 221 222 // 27.7.2.7 Unformatted output: 223 basic_ostream& put(char_type __c); 224 basic_ostream& write(const char_type* __s, streamsize __n); 225 basic_ostream& flush(); 226 227 // 27.7.2.5 seeks: 228 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 229 pos_type tellp(); 230 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 231 basic_ostream& seekp(pos_type __pos); 232 inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 233 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir); 234 235 protected: 236 _LIBCPP_INLINE_VISIBILITY 237 basic_ostream() {} // extension, intentially does not initialize 238 }; 239 240 template <class _CharT, class _Traits> 241 class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry 242 { 243 bool __ok_; 244 basic_ostream<_CharT, _Traits>& __os_; 245 246 sentry(const sentry&); // = delete; 247 sentry& operator=(const sentry&); // = delete; 248 249 public: 250 explicit sentry(basic_ostream<_CharT, _Traits>& __os); 251 ~sentry(); 252 253 _LIBCPP_INLINE_VISIBILITY 254 _LIBCPP_EXPLICIT 255 operator bool() const {return __ok_;} 256 }; 257 258 template <class _CharT, class _Traits> 259 basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os) 260 : __ok_(false), 261 __os_(__os) 262 { 263 if (__os.good()) 264 { 265 if (__os.tie()) 266 __os.tie()->flush(); 267 __ok_ = true; 268 } 269 } 270 271 template <class _CharT, class _Traits> 272 basic_ostream<_CharT, _Traits>::sentry::~sentry() 273 { 274 if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) 275 && !uncaught_exception()) 276 { 277 #ifndef _LIBCPP_NO_EXCEPTIONS 278 try 279 { 280 #endif // _LIBCPP_NO_EXCEPTIONS 281 if (__os_.rdbuf()->pubsync() == -1) 282 __os_.setstate(ios_base::badbit); 283 #ifndef _LIBCPP_NO_EXCEPTIONS 284 } 285 catch (...) 286 { 287 } 288 #endif // _LIBCPP_NO_EXCEPTIONS 289 } 290 } 291 292 #ifndef _LIBCPP_CXX03_LANG 293 294 template <class _CharT, class _Traits> 295 basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) 296 { 297 this->move(__rhs); 298 } 299 300 template <class _CharT, class _Traits> 301 basic_ostream<_CharT, _Traits>& 302 basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) 303 { 304 swap(__rhs); 305 return *this; 306 } 307 308 #endif // _LIBCPP_CXX03_LANG 309 310 template <class _CharT, class _Traits> 311 basic_ostream<_CharT, _Traits>::~basic_ostream() 312 { 313 } 314 315 template <class _CharT, class _Traits> 316 basic_ostream<_CharT, _Traits>& 317 basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) 318 { 319 #ifndef _LIBCPP_NO_EXCEPTIONS 320 try 321 { 322 #endif // _LIBCPP_NO_EXCEPTIONS 323 sentry __s(*this); 324 if (__s) 325 { 326 if (__sb) 327 { 328 #ifndef _LIBCPP_NO_EXCEPTIONS 329 try 330 { 331 #endif // _LIBCPP_NO_EXCEPTIONS 332 typedef istreambuf_iterator<_CharT, _Traits> _Ip; 333 typedef ostreambuf_iterator<_CharT, _Traits> _Op; 334 _Ip __i(__sb); 335 _Ip __eof; 336 _Op __o(*this); 337 size_t __c = 0; 338 for (; __i != __eof; ++__i, ++__o, ++__c) 339 { 340 *__o = *__i; 341 if (__o.failed()) 342 break; 343 } 344 if (__c == 0) 345 this->setstate(ios_base::failbit); 346 #ifndef _LIBCPP_NO_EXCEPTIONS 347 } 348 catch (...) 349 { 350 this->__set_failbit_and_consider_rethrow(); 351 } 352 #endif // _LIBCPP_NO_EXCEPTIONS 353 } 354 else 355 this->setstate(ios_base::badbit); 356 } 357 #ifndef _LIBCPP_NO_EXCEPTIONS 358 } 359 catch (...) 360 { 361 this->__set_badbit_and_consider_rethrow(); 362 } 363 #endif // _LIBCPP_NO_EXCEPTIONS 364 return *this; 365 } 366 367 template <class _CharT, class _Traits> 368 basic_ostream<_CharT, _Traits>& 369 basic_ostream<_CharT, _Traits>::operator<<(bool __n) 370 { 371 #ifndef _LIBCPP_NO_EXCEPTIONS 372 try 373 { 374 #endif // _LIBCPP_NO_EXCEPTIONS 375 sentry __s(*this); 376 if (__s) 377 { 378 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 379 const _Fp& __f = use_facet<_Fp>(this->getloc()); 380 if (__f.put(*this, *this, this->fill(), __n).failed()) 381 this->setstate(ios_base::badbit | ios_base::failbit); 382 } 383 #ifndef _LIBCPP_NO_EXCEPTIONS 384 } 385 catch (...) 386 { 387 this->__set_badbit_and_consider_rethrow(); 388 } 389 #endif // _LIBCPP_NO_EXCEPTIONS 390 return *this; 391 } 392 393 template <class _CharT, class _Traits> 394 basic_ostream<_CharT, _Traits>& 395 basic_ostream<_CharT, _Traits>::operator<<(short __n) 396 { 397 #ifndef _LIBCPP_NO_EXCEPTIONS 398 try 399 { 400 #endif // _LIBCPP_NO_EXCEPTIONS 401 sentry __s(*this); 402 if (__s) 403 { 404 ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield; 405 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 406 const _Fp& __f = use_facet<_Fp>(this->getloc()); 407 if (__f.put(*this, *this, this->fill(), 408 __flags == ios_base::oct || __flags == ios_base::hex ? 409 static_cast<long>(static_cast<unsigned short>(__n)) : 410 static_cast<long>(__n)).failed()) 411 this->setstate(ios_base::badbit | ios_base::failbit); 412 } 413 #ifndef _LIBCPP_NO_EXCEPTIONS 414 } 415 catch (...) 416 { 417 this->__set_badbit_and_consider_rethrow(); 418 } 419 #endif // _LIBCPP_NO_EXCEPTIONS 420 return *this; 421 } 422 423 template <class _CharT, class _Traits> 424 basic_ostream<_CharT, _Traits>& 425 basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) 426 { 427 #ifndef _LIBCPP_NO_EXCEPTIONS 428 try 429 { 430 #endif // _LIBCPP_NO_EXCEPTIONS 431 sentry __s(*this); 432 if (__s) 433 { 434 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 435 const _Fp& __f = use_facet<_Fp>(this->getloc()); 436 if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed()) 437 this->setstate(ios_base::badbit | ios_base::failbit); 438 } 439 #ifndef _LIBCPP_NO_EXCEPTIONS 440 } 441 catch (...) 442 { 443 this->__set_badbit_and_consider_rethrow(); 444 } 445 #endif // _LIBCPP_NO_EXCEPTIONS 446 return *this; 447 } 448 449 template <class _CharT, class _Traits> 450 basic_ostream<_CharT, _Traits>& 451 basic_ostream<_CharT, _Traits>::operator<<(int __n) 452 { 453 #ifndef _LIBCPP_NO_EXCEPTIONS 454 try 455 { 456 #endif // _LIBCPP_NO_EXCEPTIONS 457 sentry __s(*this); 458 if (__s) 459 { 460 ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield; 461 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 462 const _Fp& __f = use_facet<_Fp>(this->getloc()); 463 if (__f.put(*this, *this, this->fill(), 464 __flags == ios_base::oct || __flags == ios_base::hex ? 465 static_cast<long>(static_cast<unsigned int>(__n)) : 466 static_cast<long>(__n)).failed()) 467 this->setstate(ios_base::badbit | ios_base::failbit); 468 } 469 #ifndef _LIBCPP_NO_EXCEPTIONS 470 } 471 catch (...) 472 { 473 this->__set_badbit_and_consider_rethrow(); 474 } 475 #endif // _LIBCPP_NO_EXCEPTIONS 476 return *this; 477 } 478 479 template <class _CharT, class _Traits> 480 basic_ostream<_CharT, _Traits>& 481 basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) 482 { 483 #ifndef _LIBCPP_NO_EXCEPTIONS 484 try 485 { 486 #endif // _LIBCPP_NO_EXCEPTIONS 487 sentry __s(*this); 488 if (__s) 489 { 490 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 491 const _Fp& __f = use_facet<_Fp>(this->getloc()); 492 if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed()) 493 this->setstate(ios_base::badbit | ios_base::failbit); 494 } 495 #ifndef _LIBCPP_NO_EXCEPTIONS 496 } 497 catch (...) 498 { 499 this->__set_badbit_and_consider_rethrow(); 500 } 501 #endif // _LIBCPP_NO_EXCEPTIONS 502 return *this; 503 } 504 505 template <class _CharT, class _Traits> 506 basic_ostream<_CharT, _Traits>& 507 basic_ostream<_CharT, _Traits>::operator<<(long __n) 508 { 509 #ifndef _LIBCPP_NO_EXCEPTIONS 510 try 511 { 512 #endif // _LIBCPP_NO_EXCEPTIONS 513 sentry __s(*this); 514 if (__s) 515 { 516 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 517 const _Fp& __f = use_facet<_Fp>(this->getloc()); 518 if (__f.put(*this, *this, this->fill(), __n).failed()) 519 this->setstate(ios_base::badbit | ios_base::failbit); 520 } 521 #ifndef _LIBCPP_NO_EXCEPTIONS 522 } 523 catch (...) 524 { 525 this->__set_badbit_and_consider_rethrow(); 526 } 527 #endif // _LIBCPP_NO_EXCEPTIONS 528 return *this; 529 } 530 531 template <class _CharT, class _Traits> 532 basic_ostream<_CharT, _Traits>& 533 basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) 534 { 535 #ifndef _LIBCPP_NO_EXCEPTIONS 536 try 537 { 538 #endif // _LIBCPP_NO_EXCEPTIONS 539 sentry __s(*this); 540 if (__s) 541 { 542 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 543 const _Fp& __f = use_facet<_Fp>(this->getloc()); 544 if (__f.put(*this, *this, this->fill(), __n).failed()) 545 this->setstate(ios_base::badbit | ios_base::failbit); 546 } 547 #ifndef _LIBCPP_NO_EXCEPTIONS 548 } 549 catch (...) 550 { 551 this->__set_badbit_and_consider_rethrow(); 552 } 553 #endif // _LIBCPP_NO_EXCEPTIONS 554 return *this; 555 } 556 557 template <class _CharT, class _Traits> 558 basic_ostream<_CharT, _Traits>& 559 basic_ostream<_CharT, _Traits>::operator<<(long long __n) 560 { 561 #ifndef _LIBCPP_NO_EXCEPTIONS 562 try 563 { 564 #endif // _LIBCPP_NO_EXCEPTIONS 565 sentry __s(*this); 566 if (__s) 567 { 568 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 569 const _Fp& __f = use_facet<_Fp>(this->getloc()); 570 if (__f.put(*this, *this, this->fill(), __n).failed()) 571 this->setstate(ios_base::badbit | ios_base::failbit); 572 } 573 #ifndef _LIBCPP_NO_EXCEPTIONS 574 } 575 catch (...) 576 { 577 this->__set_badbit_and_consider_rethrow(); 578 } 579 #endif // _LIBCPP_NO_EXCEPTIONS 580 return *this; 581 } 582 583 template <class _CharT, class _Traits> 584 basic_ostream<_CharT, _Traits>& 585 basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) 586 { 587 #ifndef _LIBCPP_NO_EXCEPTIONS 588 try 589 { 590 #endif // _LIBCPP_NO_EXCEPTIONS 591 sentry __s(*this); 592 if (__s) 593 { 594 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 595 const _Fp& __f = use_facet<_Fp>(this->getloc()); 596 if (__f.put(*this, *this, this->fill(), __n).failed()) 597 this->setstate(ios_base::badbit | ios_base::failbit); 598 } 599 #ifndef _LIBCPP_NO_EXCEPTIONS 600 } 601 catch (...) 602 { 603 this->__set_badbit_and_consider_rethrow(); 604 } 605 #endif // _LIBCPP_NO_EXCEPTIONS 606 return *this; 607 } 608 609 template <class _CharT, class _Traits> 610 basic_ostream<_CharT, _Traits>& 611 basic_ostream<_CharT, _Traits>::operator<<(float __n) 612 { 613 #ifndef _LIBCPP_NO_EXCEPTIONS 614 try 615 { 616 #endif // _LIBCPP_NO_EXCEPTIONS 617 sentry __s(*this); 618 if (__s) 619 { 620 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 621 const _Fp& __f = use_facet<_Fp>(this->getloc()); 622 if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed()) 623 this->setstate(ios_base::badbit | ios_base::failbit); 624 } 625 #ifndef _LIBCPP_NO_EXCEPTIONS 626 } 627 catch (...) 628 { 629 this->__set_badbit_and_consider_rethrow(); 630 } 631 #endif // _LIBCPP_NO_EXCEPTIONS 632 return *this; 633 } 634 635 template <class _CharT, class _Traits> 636 basic_ostream<_CharT, _Traits>& 637 basic_ostream<_CharT, _Traits>::operator<<(double __n) 638 { 639 #ifndef _LIBCPP_NO_EXCEPTIONS 640 try 641 { 642 #endif // _LIBCPP_NO_EXCEPTIONS 643 sentry __s(*this); 644 if (__s) 645 { 646 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 647 const _Fp& __f = use_facet<_Fp>(this->getloc()); 648 if (__f.put(*this, *this, this->fill(), __n).failed()) 649 this->setstate(ios_base::badbit | ios_base::failbit); 650 } 651 #ifndef _LIBCPP_NO_EXCEPTIONS 652 } 653 catch (...) 654 { 655 this->__set_badbit_and_consider_rethrow(); 656 } 657 #endif // _LIBCPP_NO_EXCEPTIONS 658 return *this; 659 } 660 661 template <class _CharT, class _Traits> 662 basic_ostream<_CharT, _Traits>& 663 basic_ostream<_CharT, _Traits>::operator<<(long double __n) 664 { 665 #ifndef _LIBCPP_NO_EXCEPTIONS 666 try 667 { 668 #endif // _LIBCPP_NO_EXCEPTIONS 669 sentry __s(*this); 670 if (__s) 671 { 672 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 673 const _Fp& __f = use_facet<_Fp>(this->getloc()); 674 if (__f.put(*this, *this, this->fill(), __n).failed()) 675 this->setstate(ios_base::badbit | ios_base::failbit); 676 } 677 #ifndef _LIBCPP_NO_EXCEPTIONS 678 } 679 catch (...) 680 { 681 this->__set_badbit_and_consider_rethrow(); 682 } 683 #endif // _LIBCPP_NO_EXCEPTIONS 684 return *this; 685 } 686 687 template <class _CharT, class _Traits> 688 basic_ostream<_CharT, _Traits>& 689 basic_ostream<_CharT, _Traits>::operator<<(const void* __n) 690 { 691 #ifndef _LIBCPP_NO_EXCEPTIONS 692 try 693 { 694 #endif // _LIBCPP_NO_EXCEPTIONS 695 sentry __s(*this); 696 if (__s) 697 { 698 typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp; 699 const _Fp& __f = use_facet<_Fp>(this->getloc()); 700 if (__f.put(*this, *this, this->fill(), __n).failed()) 701 this->setstate(ios_base::badbit | ios_base::failbit); 702 } 703 #ifndef _LIBCPP_NO_EXCEPTIONS 704 } 705 catch (...) 706 { 707 this->__set_badbit_and_consider_rethrow(); 708 } 709 #endif // _LIBCPP_NO_EXCEPTIONS 710 return *this; 711 } 712 713 template<class _CharT, class _Traits> 714 basic_ostream<_CharT, _Traits>& 715 __put_character_sequence(basic_ostream<_CharT, _Traits>& __os, 716 const _CharT* __str, size_t __len) 717 { 718 #ifndef _LIBCPP_NO_EXCEPTIONS 719 try 720 { 721 #endif // _LIBCPP_NO_EXCEPTIONS 722 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 723 if (__s) 724 { 725 typedef ostreambuf_iterator<_CharT, _Traits> _Ip; 726 if (__pad_and_output(_Ip(__os), 727 __str, 728 (__os.flags() & ios_base::adjustfield) == ios_base::left ? 729 __str + __len : 730 __str, 731 __str + __len, 732 __os, 733 __os.fill()).failed()) 734 __os.setstate(ios_base::badbit | ios_base::failbit); 735 } 736 #ifndef _LIBCPP_NO_EXCEPTIONS 737 } 738 catch (...) 739 { 740 __os.__set_badbit_and_consider_rethrow(); 741 } 742 #endif // _LIBCPP_NO_EXCEPTIONS 743 return __os; 744 } 745 746 747 template<class _CharT, class _Traits> 748 basic_ostream<_CharT, _Traits>& 749 operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) 750 { 751 return _VSTD::__put_character_sequence(__os, &__c, 1); 752 } 753 754 template<class _CharT, class _Traits> 755 basic_ostream<_CharT, _Traits>& 756 operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) 757 { 758 #ifndef _LIBCPP_NO_EXCEPTIONS 759 try 760 { 761 #endif // _LIBCPP_NO_EXCEPTIONS 762 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 763 if (__s) 764 { 765 _CharT __c = __os.widen(__cn); 766 typedef ostreambuf_iterator<_CharT, _Traits> _Ip; 767 if (__pad_and_output(_Ip(__os), 768 &__c, 769 (__os.flags() & ios_base::adjustfield) == ios_base::left ? 770 &__c + 1 : 771 &__c, 772 &__c + 1, 773 __os, 774 __os.fill()).failed()) 775 __os.setstate(ios_base::badbit | ios_base::failbit); 776 } 777 #ifndef _LIBCPP_NO_EXCEPTIONS 778 } 779 catch (...) 780 { 781 __os.__set_badbit_and_consider_rethrow(); 782 } 783 #endif // _LIBCPP_NO_EXCEPTIONS 784 return __os; 785 } 786 787 template<class _Traits> 788 basic_ostream<char, _Traits>& 789 operator<<(basic_ostream<char, _Traits>& __os, char __c) 790 { 791 return _VSTD::__put_character_sequence(__os, &__c, 1); 792 } 793 794 template<class _Traits> 795 basic_ostream<char, _Traits>& 796 operator<<(basic_ostream<char, _Traits>& __os, signed char __c) 797 { 798 return _VSTD::__put_character_sequence(__os, (char *) &__c, 1); 799 } 800 801 template<class _Traits> 802 basic_ostream<char, _Traits>& 803 operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) 804 { 805 return _VSTD::__put_character_sequence(__os, (char *) &__c, 1); 806 } 807 808 template<class _CharT, class _Traits> 809 basic_ostream<_CharT, _Traits>& 810 operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) 811 { 812 return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); 813 } 814 815 template<class _CharT, class _Traits> 816 basic_ostream<_CharT, _Traits>& 817 operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) 818 { 819 #ifndef _LIBCPP_NO_EXCEPTIONS 820 try 821 { 822 #endif // _LIBCPP_NO_EXCEPTIONS 823 typename basic_ostream<_CharT, _Traits>::sentry __s(__os); 824 if (__s) 825 { 826 typedef ostreambuf_iterator<_CharT, _Traits> _Ip; 827 size_t __len = char_traits<char>::length(__strn); 828 const int __bs = 100; 829 _CharT __wbb[__bs]; 830 _CharT* __wb = __wbb; 831 unique_ptr<_CharT, void(*)(void*)> __h(0, free); 832 if (__len > __bs) 833 { 834 __wb = (_CharT*)malloc(__len*sizeof(_CharT)); 835 if (__wb == 0) 836 __throw_bad_alloc(); 837 __h.reset(__wb); 838 } 839 for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p) 840 *__p = __os.widen(*__strn); 841 if (__pad_and_output(_Ip(__os), 842 __wb, 843 (__os.flags() & ios_base::adjustfield) == ios_base::left ? 844 __wb + __len : 845 __wb, 846 __wb + __len, 847 __os, 848 __os.fill()).failed()) 849 __os.setstate(ios_base::badbit | ios_base::failbit); 850 } 851 #ifndef _LIBCPP_NO_EXCEPTIONS 852 } 853 catch (...) 854 { 855 __os.__set_badbit_and_consider_rethrow(); 856 } 857 #endif // _LIBCPP_NO_EXCEPTIONS 858 return __os; 859 } 860 861 template<class _Traits> 862 basic_ostream<char, _Traits>& 863 operator<<(basic_ostream<char, _Traits>& __os, const char* __str) 864 { 865 return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str)); 866 } 867 868 template<class _Traits> 869 basic_ostream<char, _Traits>& 870 operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) 871 { 872 const char *__s = (const char *) __str; 873 return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s)); 874 } 875 876 template<class _Traits> 877 basic_ostream<char, _Traits>& 878 operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) 879 { 880 const char *__s = (const char *) __str; 881 return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s)); 882 } 883 884 template <class _CharT, class _Traits> 885 basic_ostream<_CharT, _Traits>& 886 basic_ostream<_CharT, _Traits>::put(char_type __c) 887 { 888 #ifndef _LIBCPP_NO_EXCEPTIONS 889 try 890 { 891 #endif // _LIBCPP_NO_EXCEPTIONS 892 sentry __s(*this); 893 if (__s) 894 { 895 typedef ostreambuf_iterator<_CharT, _Traits> _Op; 896 _Op __o(*this); 897 *__o = __c; 898 if (__o.failed()) 899 this->setstate(ios_base::badbit); 900 } 901 #ifndef _LIBCPP_NO_EXCEPTIONS 902 } 903 catch (...) 904 { 905 this->__set_badbit_and_consider_rethrow(); 906 } 907 #endif // _LIBCPP_NO_EXCEPTIONS 908 return *this; 909 } 910 911 template <class _CharT, class _Traits> 912 basic_ostream<_CharT, _Traits>& 913 basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) 914 { 915 #ifndef _LIBCPP_NO_EXCEPTIONS 916 try 917 { 918 #endif // _LIBCPP_NO_EXCEPTIONS 919 sentry __sen(*this); 920 if (__sen && __n) 921 { 922 if (this->rdbuf()->sputn(__s, __n) != __n) 923 this->setstate(ios_base::badbit); 924 } 925 #ifndef _LIBCPP_NO_EXCEPTIONS 926 } 927 catch (...) 928 { 929 this->__set_badbit_and_consider_rethrow(); 930 } 931 #endif // _LIBCPP_NO_EXCEPTIONS 932 return *this; 933 } 934 935 template <class _CharT, class _Traits> 936 basic_ostream<_CharT, _Traits>& 937 basic_ostream<_CharT, _Traits>::flush() 938 { 939 #ifndef _LIBCPP_NO_EXCEPTIONS 940 try 941 { 942 #endif // _LIBCPP_NO_EXCEPTIONS 943 if (this->rdbuf()) 944 { 945 sentry __s(*this); 946 if (__s) 947 { 948 if (this->rdbuf()->pubsync() == -1) 949 this->setstate(ios_base::badbit); 950 } 951 } 952 #ifndef _LIBCPP_NO_EXCEPTIONS 953 } 954 catch (...) 955 { 956 this->__set_badbit_and_consider_rethrow(); 957 } 958 #endif // _LIBCPP_NO_EXCEPTIONS 959 return *this; 960 } 961 962 template <class _CharT, class _Traits> 963 typename basic_ostream<_CharT, _Traits>::pos_type 964 basic_ostream<_CharT, _Traits>::tellp() 965 { 966 if (this->fail()) 967 return pos_type(-1); 968 return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); 969 } 970 971 template <class _CharT, class _Traits> 972 basic_ostream<_CharT, _Traits>& 973 basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) 974 { 975 sentry __s(*this); 976 if (!this->fail()) 977 { 978 if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1)) 979 this->setstate(ios_base::failbit); 980 } 981 return *this; 982 } 983 984 template <class _CharT, class _Traits> 985 basic_ostream<_CharT, _Traits>& 986 basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) 987 { 988 sentry __s(*this); 989 if (!this->fail()) 990 { 991 if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1)) 992 this->setstate(ios_base::failbit); 993 } 994 return *this; 995 } 996 997 template <class _CharT, class _Traits> 998 inline _LIBCPP_INLINE_VISIBILITY 999 basic_ostream<_CharT, _Traits>& 1000 endl(basic_ostream<_CharT, _Traits>& __os) 1001 { 1002 __os.put(__os.widen('\n')); 1003 __os.flush(); 1004 return __os; 1005 } 1006 1007 template <class _CharT, class _Traits> 1008 inline _LIBCPP_INLINE_VISIBILITY 1009 basic_ostream<_CharT, _Traits>& 1010 ends(basic_ostream<_CharT, _Traits>& __os) 1011 { 1012 __os.put(_CharT()); 1013 return __os; 1014 } 1015 1016 template <class _CharT, class _Traits> 1017 inline _LIBCPP_INLINE_VISIBILITY 1018 basic_ostream<_CharT, _Traits>& 1019 flush(basic_ostream<_CharT, _Traits>& __os) 1020 { 1021 __os.flush(); 1022 return __os; 1023 } 1024 1025 #ifndef _LIBCPP_CXX03_LANG 1026 1027 template <class _Stream, class _Tp> 1028 inline _LIBCPP_INLINE_VISIBILITY 1029 typename enable_if 1030 < 1031 !is_lvalue_reference<_Stream>::value && 1032 is_base_of<ios_base, _Stream>::value, 1033 _Stream&& 1034 >::type 1035 operator<<(_Stream&& __os, const _Tp& __x) 1036 { 1037 __os << __x; 1038 return _VSTD::move(__os); 1039 } 1040 1041 #endif // _LIBCPP_CXX03_LANG 1042 1043 template<class _CharT, class _Traits, class _Allocator> 1044 basic_ostream<_CharT, _Traits>& 1045 operator<<(basic_ostream<_CharT, _Traits>& __os, 1046 const basic_string<_CharT, _Traits, _Allocator>& __str) 1047 { 1048 return _VSTD::__put_character_sequence(__os, __str.data(), __str.size()); 1049 } 1050 1051 template<class _CharT, class _Traits> 1052 basic_ostream<_CharT, _Traits>& 1053 operator<<(basic_ostream<_CharT, _Traits>& __os, 1054 const basic_string_view<_CharT, _Traits> __sv) 1055 { 1056 return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size()); 1057 } 1058 1059 template <class _CharT, class _Traits> 1060 inline _LIBCPP_INLINE_VISIBILITY 1061 basic_ostream<_CharT, _Traits>& 1062 operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec) 1063 { 1064 return __os << __ec.category().name() << ':' << __ec.value(); 1065 } 1066 1067 template<class _CharT, class _Traits, class _Yp> 1068 inline _LIBCPP_INLINE_VISIBILITY 1069 basic_ostream<_CharT, _Traits>& 1070 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p) 1071 { 1072 return __os << __p.get(); 1073 } 1074 1075 template<class _CharT, class _Traits, class _Yp, class _Dp> 1076 inline _LIBCPP_INLINE_VISIBILITY 1077 typename enable_if 1078 < 1079 is_same<void, typename __void_t<decltype((declval<basic_ostream<_CharT, _Traits>&>() << declval<typename unique_ptr<_Yp, _Dp>::pointer>()))>::type>::value, 1080 basic_ostream<_CharT, _Traits>& 1081 >::type 1082 operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) 1083 { 1084 return __os << __p.get(); 1085 } 1086 1087 template <class _CharT, class _Traits, size_t _Size> 1088 basic_ostream<_CharT, _Traits>& 1089 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) 1090 { 1091 return __os << __x.template to_string<_CharT, _Traits> 1092 (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'), 1093 use_facet<ctype<_CharT> >(__os.getloc()).widen('1')); 1094 } 1095 1096 #ifndef _LIBCPP_DO_NOT_ASSUME_STREAMS_EXPLICIT_INSTANTIATION_IN_DYLIB 1097 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>) 1098 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>) 1099 #endif 1100 1101 _LIBCPP_END_NAMESPACE_STD 1102 1103 #endif // _LIBCPP_OSTREAM 1104
