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