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