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