1 // -*- C++ -*- 2 //===---------------------------- ios -------------------------------------===// 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_IOS 11 #define _LIBCPP_IOS 12 13 /* 14 ios synopsis 15 16 #include <iosfwd> 17 18 namespace std 19 { 20 21 typedef OFF_T streamoff; 22 typedef SZ_T streamsize; 23 template <class stateT> class fpos; 24 25 class ios_base 26 { 27 public: 28 class failure; 29 30 typedef T1 fmtflags; 31 static constexpr fmtflags boolalpha; 32 static constexpr fmtflags dec; 33 static constexpr fmtflags fixed; 34 static constexpr fmtflags hex; 35 static constexpr fmtflags internal; 36 static constexpr fmtflags left; 37 static constexpr fmtflags oct; 38 static constexpr fmtflags right; 39 static constexpr fmtflags scientific; 40 static constexpr fmtflags showbase; 41 static constexpr fmtflags showpoint; 42 static constexpr fmtflags showpos; 43 static constexpr fmtflags skipws; 44 static constexpr fmtflags unitbuf; 45 static constexpr fmtflags uppercase; 46 static constexpr fmtflags adjustfield; 47 static constexpr fmtflags basefield; 48 static constexpr fmtflags floatfield; 49 50 typedef T2 iostate; 51 static constexpr iostate badbit; 52 static constexpr iostate eofbit; 53 static constexpr iostate failbit; 54 static constexpr iostate goodbit; 55 56 typedef T3 openmode; 57 static constexpr openmode app; 58 static constexpr openmode ate; 59 static constexpr openmode binary; 60 static constexpr openmode in; 61 static constexpr openmode out; 62 static constexpr openmode trunc; 63 64 typedef T4 seekdir; 65 static constexpr seekdir beg; 66 static constexpr seekdir cur; 67 static constexpr seekdir end; 68 69 class Init; 70 71 // 27.5.2.2 fmtflags state: 72 fmtflags flags() const; 73 fmtflags flags(fmtflags fmtfl); 74 fmtflags setf(fmtflags fmtfl); 75 fmtflags setf(fmtflags fmtfl, fmtflags mask); 76 void unsetf(fmtflags mask); 77 78 streamsize precision() const; 79 streamsize precision(streamsize prec); 80 streamsize width() const; 81 streamsize width(streamsize wide); 82 83 // 27.5.2.3 locales: 84 locale imbue(const locale& loc); 85 locale getloc() const; 86 87 // 27.5.2.5 storage: 88 static int xalloc(); 89 long& iword(int index); 90 void*& pword(int index); 91 92 // destructor 93 virtual ~ios_base(); 94 95 // 27.5.2.6 callbacks; 96 enum event { erase_event, imbue_event, copyfmt_event }; 97 typedef void (*event_callback)(event, ios_base&, int index); 98 void register_callback(event_callback fn, int index); 99 100 ios_base(const ios_base&) = delete; 101 ios_base& operator=(const ios_base&) = delete; 102 103 static bool sync_with_stdio(bool sync = true); 104 105 protected: 106 ios_base(); 107 }; 108 109 template <class charT, class traits = char_traits<charT> > 110 class basic_ios 111 : public ios_base 112 { 113 public: 114 // types: 115 typedef charT char_type; 116 typedef typename traits::int_type int_type; // removed in C++17 117 typedef typename traits::pos_type pos_type; // removed in C++17 118 typedef typename traits::off_type off_type; // removed in C++17 119 typedef traits traits_type; 120 121 operator unspecified-bool-type() const; 122 bool operator!() const; 123 iostate rdstate() const; 124 void clear(iostate state = goodbit); 125 void setstate(iostate state); 126 bool good() const; 127 bool eof() const; 128 bool fail() const; 129 bool bad() const; 130 131 iostate exceptions() const; 132 void exceptions(iostate except); 133 134 // 27.5.4.1 Constructor/destructor: 135 explicit basic_ios(basic_streambuf<charT,traits>* sb); 136 virtual ~basic_ios(); 137 138 // 27.5.4.2 Members: 139 basic_ostream<charT,traits>* tie() const; 140 basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr); 141 142 basic_streambuf<charT,traits>* rdbuf() const; 143 basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb); 144 145 basic_ios& copyfmt(const basic_ios& rhs); 146 147 char_type fill() const; 148 char_type fill(char_type ch); 149 150 locale imbue(const locale& loc); 151 152 char narrow(char_type c, char dfault) const; 153 char_type widen(char c) const; 154 155 basic_ios(const basic_ios& ) = delete; 156 basic_ios& operator=(const basic_ios&) = delete; 157 158 protected: 159 basic_ios(); 160 void init(basic_streambuf<charT,traits>* sb); 161 void move(basic_ios& rhs); 162 void swap(basic_ios& rhs) noexcept; 163 void set_rdbuf(basic_streambuf<charT, traits>* sb); 164 }; 165 166 // 27.5.5, manipulators: 167 ios_base& boolalpha (ios_base& str); 168 ios_base& noboolalpha(ios_base& str); 169 ios_base& showbase (ios_base& str); 170 ios_base& noshowbase (ios_base& str); 171 ios_base& showpoint (ios_base& str); 172 ios_base& noshowpoint(ios_base& str); 173 ios_base& showpos (ios_base& str); 174 ios_base& noshowpos (ios_base& str); 175 ios_base& skipws (ios_base& str); 176 ios_base& noskipws (ios_base& str); 177 ios_base& uppercase (ios_base& str); 178 ios_base& nouppercase(ios_base& str); 179 ios_base& unitbuf (ios_base& str); 180 ios_base& nounitbuf (ios_base& str); 181 182 // 27.5.5.2 adjustfield: 183 ios_base& internal (ios_base& str); 184 ios_base& left (ios_base& str); 185 ios_base& right (ios_base& str); 186 187 // 27.5.5.3 basefield: 188 ios_base& dec (ios_base& str); 189 ios_base& hex (ios_base& str); 190 ios_base& oct (ios_base& str); 191 192 // 27.5.5.4 floatfield: 193 ios_base& fixed (ios_base& str); 194 ios_base& scientific (ios_base& str); 195 ios_base& hexfloat (ios_base& str); 196 ios_base& defaultfloat(ios_base& str); 197 198 // 27.5.5.5 error reporting: 199 enum class io_errc 200 { 201 stream = 1 202 }; 203 204 concept_map ErrorCodeEnum<io_errc> { }; 205 error_code make_error_code(io_errc e) noexcept; 206 error_condition make_error_condition(io_errc e) noexcept; 207 storage-class-specifier const error_category& iostream_category() noexcept; 208 209 } // std 210 211 */ 212 213 #include <__config> 214 #include <iosfwd> 215 #include <__locale> 216 #include <system_error> 217 218 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) 219 #include <atomic> // for __xindex_ 220 #endif 221 222 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 223 #pragma GCC system_header 224 #endif 225 226 _LIBCPP_BEGIN_NAMESPACE_STD 227 228 typedef ptrdiff_t streamsize; 229 230 class _LIBCPP_TYPE_VIS ios_base 231 { 232 public: 233 class _LIBCPP_EXCEPTION_ABI failure; 234 235 typedef unsigned int fmtflags; 236 static const fmtflags boolalpha = 0x0001; 237 static const fmtflags dec = 0x0002; 238 static const fmtflags fixed = 0x0004; 239 static const fmtflags hex = 0x0008; 240 static const fmtflags internal = 0x0010; 241 static const fmtflags left = 0x0020; 242 static const fmtflags oct = 0x0040; 243 static const fmtflags right = 0x0080; 244 static const fmtflags scientific = 0x0100; 245 static const fmtflags showbase = 0x0200; 246 static const fmtflags showpoint = 0x0400; 247 static const fmtflags showpos = 0x0800; 248 static const fmtflags skipws = 0x1000; 249 static const fmtflags unitbuf = 0x2000; 250 static const fmtflags uppercase = 0x4000; 251 static const fmtflags adjustfield = left | right | internal; 252 static const fmtflags basefield = dec | oct | hex; 253 static const fmtflags floatfield = scientific | fixed; 254 255 typedef unsigned int iostate; 256 static const iostate badbit = 0x1; 257 static const iostate eofbit = 0x2; 258 static const iostate failbit = 0x4; 259 static const iostate goodbit = 0x0; 260 261 typedef unsigned int openmode; 262 static const openmode app = 0x01; 263 static const openmode ate = 0x02; 264 static const openmode binary = 0x04; 265 static const openmode in = 0x08; 266 static const openmode out = 0x10; 267 static const openmode trunc = 0x20; 268 269 enum seekdir {beg, cur, end}; 270 271 #if _LIBCPP_STD_VER <= 14 272 typedef iostate io_state; 273 typedef openmode open_mode; 274 typedef seekdir seek_dir; 275 276 typedef _VSTD::streamoff streamoff; 277 typedef _VSTD::streampos streampos; 278 #endif 279 280 class _LIBCPP_TYPE_VIS Init; 281 282 // 27.5.2.2 fmtflags state: 283 _LIBCPP_INLINE_VISIBILITY fmtflags flags() const; 284 _LIBCPP_INLINE_VISIBILITY fmtflags flags(fmtflags __fmtfl); 285 _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl); 286 _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl, fmtflags __mask); 287 _LIBCPP_INLINE_VISIBILITY void unsetf(fmtflags __mask); 288 289 _LIBCPP_INLINE_VISIBILITY streamsize precision() const; 290 _LIBCPP_INLINE_VISIBILITY streamsize precision(streamsize __prec); 291 _LIBCPP_INLINE_VISIBILITY streamsize width() const; 292 _LIBCPP_INLINE_VISIBILITY streamsize width(streamsize __wide); 293 294 // 27.5.2.3 locales: 295 locale imbue(const locale& __loc); 296 locale getloc() const; 297 298 // 27.5.2.5 storage: 299 static int xalloc(); 300 long& iword(int __index); 301 void*& pword(int __index); 302 303 // destructor 304 virtual ~ios_base(); 305 306 // 27.5.2.6 callbacks; 307 enum event { erase_event, imbue_event, copyfmt_event }; 308 typedef void (*event_callback)(event, ios_base&, int __index); 309 void register_callback(event_callback __fn, int __index); 310 311 private: 312 ios_base(const ios_base&); // = delete; 313 ios_base& operator=(const ios_base&); // = delete; 314 315 public: 316 static bool sync_with_stdio(bool __sync = true); 317 318 _LIBCPP_INLINE_VISIBILITY iostate rdstate() const; 319 void clear(iostate __state = goodbit); 320 _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state); 321 322 _LIBCPP_INLINE_VISIBILITY bool good() const; 323 _LIBCPP_INLINE_VISIBILITY bool eof() const; 324 _LIBCPP_INLINE_VISIBILITY bool fail() const; 325 _LIBCPP_INLINE_VISIBILITY bool bad() const; 326 327 _LIBCPP_INLINE_VISIBILITY iostate exceptions() const; 328 _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate); 329 330 void __set_badbit_and_consider_rethrow(); 331 void __set_failbit_and_consider_rethrow(); 332 333 _LIBCPP_INLINE_VISIBILITY 334 void __setstate_nothrow(iostate __state) 335 { 336 if (__rdbuf_) 337 __rdstate_ |= __state; 338 else 339 __rdstate_ |= __state | ios_base::badbit; 340 } 341 342 protected: 343 _LIBCPP_INLINE_VISIBILITY 344 ios_base() {// purposefully does no initialization 345 } 346 347 void init(void* __sb); 348 _LIBCPP_INLINE_VISIBILITY void* rdbuf() const {return __rdbuf_;} 349 350 _LIBCPP_INLINE_VISIBILITY 351 void rdbuf(void* __sb) 352 { 353 __rdbuf_ = __sb; 354 clear(); 355 } 356 357 void __call_callbacks(event); 358 void copyfmt(const ios_base&); 359 void move(ios_base&); 360 void swap(ios_base&) _NOEXCEPT; 361 362 _LIBCPP_INLINE_VISIBILITY 363 void set_rdbuf(void* __sb) 364 { 365 __rdbuf_ = __sb; 366 } 367 368 private: 369 // All data members must be scalars 370 fmtflags __fmtflags_; 371 streamsize __precision_; 372 streamsize __width_; 373 iostate __rdstate_; 374 iostate __exceptions_; 375 void* __rdbuf_; 376 void* __loc_; 377 event_callback* __fn_; 378 int* __index_; 379 size_t __event_size_; 380 size_t __event_cap_; 381 // TODO(EricWF): Enable this for both Clang and GCC. Currently it is only 382 // enabled with clang. 383 #if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS) 384 static atomic<int> __xindex_; 385 #else 386 static int __xindex_; 387 #endif 388 long* __iarray_; 389 size_t __iarray_size_; 390 size_t __iarray_cap_; 391 void** __parray_; 392 size_t __parray_size_; 393 size_t __parray_cap_; 394 }; 395 396 //enum class io_errc 397 _LIBCPP_DECLARE_STRONG_ENUM(io_errc) 398 { 399 stream = 1 400 }; 401 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc) 402 403 template <> 404 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { }; 405 406 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 407 template <> 408 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { }; 409 #endif 410 411 _LIBCPP_FUNC_VIS 412 const error_category& iostream_category() _NOEXCEPT; 413 414 inline _LIBCPP_INLINE_VISIBILITY 415 error_code 416 make_error_code(io_errc __e) _NOEXCEPT 417 { 418 return error_code(static_cast<int>(__e), iostream_category()); 419 } 420 421 inline _LIBCPP_INLINE_VISIBILITY 422 error_condition 423 make_error_condition(io_errc __e) _NOEXCEPT 424 { 425 return error_condition(static_cast<int>(__e), iostream_category()); 426 } 427 428 class _LIBCPP_EXCEPTION_ABI ios_base::failure 429 : public system_error 430 { 431 public: 432 explicit failure(const string& __msg, const error_code& __ec = io_errc::stream); 433 explicit failure(const char* __msg, const error_code& __ec = io_errc::stream); 434 failure(const failure&) _NOEXCEPT = default; 435 virtual ~failure() _NOEXCEPT; 436 }; 437 438 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY 439 void __throw_failure(char const* __msg) { 440 #ifndef _LIBCPP_NO_EXCEPTIONS 441 throw ios_base::failure(__msg); 442 #else 443 ((void)__msg); 444 _VSTD::abort(); 445 #endif 446 } 447 448 class _LIBCPP_TYPE_VIS ios_base::Init 449 { 450 public: 451 Init(); 452 ~Init(); 453 }; 454 455 // fmtflags 456 457 inline _LIBCPP_INLINE_VISIBILITY 458 ios_base::fmtflags 459 ios_base::flags() const 460 { 461 return __fmtflags_; 462 } 463 464 inline _LIBCPP_INLINE_VISIBILITY 465 ios_base::fmtflags 466 ios_base::flags(fmtflags __fmtfl) 467 { 468 fmtflags __r = __fmtflags_; 469 __fmtflags_ = __fmtfl; 470 return __r; 471 } 472 473 inline _LIBCPP_INLINE_VISIBILITY 474 ios_base::fmtflags 475 ios_base::setf(fmtflags __fmtfl) 476 { 477 fmtflags __r = __fmtflags_; 478 __fmtflags_ |= __fmtfl; 479 return __r; 480 } 481 482 inline _LIBCPP_INLINE_VISIBILITY 483 void 484 ios_base::unsetf(fmtflags __mask) 485 { 486 __fmtflags_ &= ~__mask; 487 } 488 489 inline _LIBCPP_INLINE_VISIBILITY 490 ios_base::fmtflags 491 ios_base::setf(fmtflags __fmtfl, fmtflags __mask) 492 { 493 fmtflags __r = __fmtflags_; 494 unsetf(__mask); 495 __fmtflags_ |= __fmtfl & __mask; 496 return __r; 497 } 498 499 // precision 500 501 inline _LIBCPP_INLINE_VISIBILITY 502 streamsize 503 ios_base::precision() const 504 { 505 return __precision_; 506 } 507 508 inline _LIBCPP_INLINE_VISIBILITY 509 streamsize 510 ios_base::precision(streamsize __prec) 511 { 512 streamsize __r = __precision_; 513 __precision_ = __prec; 514 return __r; 515 } 516 517 // width 518 519 inline _LIBCPP_INLINE_VISIBILITY 520 streamsize 521 ios_base::width() const 522 { 523 return __width_; 524 } 525 526 inline _LIBCPP_INLINE_VISIBILITY 527 streamsize 528 ios_base::width(streamsize __wide) 529 { 530 streamsize __r = __width_; 531 __width_ = __wide; 532 return __r; 533 } 534 535 // iostate 536 537 inline _LIBCPP_INLINE_VISIBILITY 538 ios_base::iostate 539 ios_base::rdstate() const 540 { 541 return __rdstate_; 542 } 543 544 inline _LIBCPP_INLINE_VISIBILITY 545 void 546 ios_base::setstate(iostate __state) 547 { 548 clear(__rdstate_ | __state); 549 } 550 551 inline _LIBCPP_INLINE_VISIBILITY 552 bool 553 ios_base::good() const 554 { 555 return __rdstate_ == 0; 556 } 557 558 inline _LIBCPP_INLINE_VISIBILITY 559 bool 560 ios_base::eof() const 561 { 562 return (__rdstate_ & eofbit) != 0; 563 } 564 565 inline _LIBCPP_INLINE_VISIBILITY 566 bool 567 ios_base::fail() const 568 { 569 return (__rdstate_ & (failbit | badbit)) != 0; 570 } 571 572 inline _LIBCPP_INLINE_VISIBILITY 573 bool 574 ios_base::bad() const 575 { 576 return (__rdstate_ & badbit) != 0; 577 } 578 579 inline _LIBCPP_INLINE_VISIBILITY 580 ios_base::iostate 581 ios_base::exceptions() const 582 { 583 return __exceptions_; 584 } 585 586 inline _LIBCPP_INLINE_VISIBILITY 587 void 588 ios_base::exceptions(iostate __iostate) 589 { 590 __exceptions_ = __iostate; 591 clear(__rdstate_); 592 } 593 594 #if defined(_LIBCPP_CXX03_LANG) 595 struct _LIBCPP_TYPE_VIS __cxx03_bool { 596 typedef void (__cxx03_bool::*__bool_type)(); 597 void __true_value() {} 598 }; 599 #endif 600 601 template <class _CharT, class _Traits> 602 class _LIBCPP_TEMPLATE_VIS basic_ios 603 : public ios_base 604 { 605 public: 606 // types: 607 typedef _CharT char_type; 608 typedef _Traits traits_type; 609 610 typedef typename traits_type::int_type int_type; 611 typedef typename traits_type::pos_type pos_type; 612 typedef typename traits_type::off_type off_type; 613 614 static_assert((is_same<_CharT, typename traits_type::char_type>::value), 615 "traits_type::char_type must be the same type as CharT"); 616 617 // __true_value will generate undefined references when linking unless 618 // we give it internal linkage. 619 620 #if defined(_LIBCPP_CXX03_LANG) 621 _LIBCPP_INLINE_VISIBILITY 622 operator __cxx03_bool::__bool_type() const { 623 return !fail() ? &__cxx03_bool::__true_value : nullptr; 624 } 625 #else 626 _LIBCPP_INLINE_VISIBILITY 627 _LIBCPP_EXPLICIT operator bool() const {return !fail();} 628 #endif 629 630 _LIBCPP_INLINE_VISIBILITY bool operator!() const {return fail();} 631 _LIBCPP_INLINE_VISIBILITY iostate rdstate() const {return ios_base::rdstate();} 632 _LIBCPP_INLINE_VISIBILITY void clear(iostate __state = goodbit) {ios_base::clear(__state);} 633 _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state) {ios_base::setstate(__state);} 634 _LIBCPP_INLINE_VISIBILITY bool good() const {return ios_base::good();} 635 _LIBCPP_INLINE_VISIBILITY bool eof() const {return ios_base::eof();} 636 _LIBCPP_INLINE_VISIBILITY bool fail() const {return ios_base::fail();} 637 _LIBCPP_INLINE_VISIBILITY bool bad() const {return ios_base::bad();} 638 639 _LIBCPP_INLINE_VISIBILITY iostate exceptions() const {return ios_base::exceptions();} 640 _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);} 641 642 // 27.5.4.1 Constructor/destructor: 643 _LIBCPP_INLINE_VISIBILITY 644 explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb); 645 virtual ~basic_ios(); 646 647 // 27.5.4.2 Members: 648 _LIBCPP_INLINE_VISIBILITY 649 basic_ostream<char_type, traits_type>* tie() const; 650 _LIBCPP_INLINE_VISIBILITY 651 basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr); 652 653 _LIBCPP_INLINE_VISIBILITY 654 basic_streambuf<char_type, traits_type>* rdbuf() const; 655 _LIBCPP_INLINE_VISIBILITY 656 basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb); 657 658 basic_ios& copyfmt(const basic_ios& __rhs); 659 660 _LIBCPP_INLINE_VISIBILITY 661 char_type fill() const; 662 _LIBCPP_INLINE_VISIBILITY 663 char_type fill(char_type __ch); 664 665 _LIBCPP_INLINE_VISIBILITY 666 locale imbue(const locale& __loc); 667 668 _LIBCPP_INLINE_VISIBILITY 669 char narrow(char_type __c, char __dfault) const; 670 _LIBCPP_INLINE_VISIBILITY 671 char_type widen(char __c) const; 672 673 protected: 674 _LIBCPP_INLINE_VISIBILITY 675 basic_ios() {// purposefully does no initialization 676 } 677 _LIBCPP_INLINE_VISIBILITY 678 void init(basic_streambuf<char_type, traits_type>* __sb); 679 680 _LIBCPP_INLINE_VISIBILITY 681 void move(basic_ios& __rhs); 682 #ifndef _LIBCPP_CXX03_LANG 683 _LIBCPP_INLINE_VISIBILITY 684 void move(basic_ios&& __rhs) {move(__rhs);} 685 #endif 686 _LIBCPP_INLINE_VISIBILITY 687 void swap(basic_ios& __rhs) _NOEXCEPT; 688 _LIBCPP_INLINE_VISIBILITY 689 void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb); 690 private: 691 basic_ostream<char_type, traits_type>* __tie_; 692 mutable int_type __fill_; 693 }; 694 695 template <class _CharT, class _Traits> 696 inline _LIBCPP_INLINE_VISIBILITY 697 basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb) 698 { 699 init(__sb); 700 } 701 702 template <class _CharT, class _Traits> 703 basic_ios<_CharT, _Traits>::~basic_ios() 704 { 705 } 706 707 template <class _CharT, class _Traits> 708 inline _LIBCPP_INLINE_VISIBILITY 709 void 710 basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb) 711 { 712 ios_base::init(__sb); 713 __tie_ = nullptr; 714 __fill_ = traits_type::eof(); 715 } 716 717 template <class _CharT, class _Traits> 718 inline _LIBCPP_INLINE_VISIBILITY 719 basic_ostream<_CharT, _Traits>* 720 basic_ios<_CharT, _Traits>::tie() const 721 { 722 return __tie_; 723 } 724 725 template <class _CharT, class _Traits> 726 inline _LIBCPP_INLINE_VISIBILITY 727 basic_ostream<_CharT, _Traits>* 728 basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr) 729 { 730 basic_ostream<char_type, traits_type>* __r = __tie_; 731 __tie_ = __tiestr; 732 return __r; 733 } 734 735 template <class _CharT, class _Traits> 736 inline _LIBCPP_INLINE_VISIBILITY 737 basic_streambuf<_CharT, _Traits>* 738 basic_ios<_CharT, _Traits>::rdbuf() const 739 { 740 return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf()); 741 } 742 743 template <class _CharT, class _Traits> 744 inline _LIBCPP_INLINE_VISIBILITY 745 basic_streambuf<_CharT, _Traits>* 746 basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb) 747 { 748 basic_streambuf<char_type, traits_type>* __r = rdbuf(); 749 ios_base::rdbuf(__sb); 750 return __r; 751 } 752 753 template <class _CharT, class _Traits> 754 inline _LIBCPP_INLINE_VISIBILITY 755 locale 756 basic_ios<_CharT, _Traits>::imbue(const locale& __loc) 757 { 758 locale __r = getloc(); 759 ios_base::imbue(__loc); 760 if (rdbuf()) 761 rdbuf()->pubimbue(__loc); 762 return __r; 763 } 764 765 template <class _CharT, class _Traits> 766 inline _LIBCPP_INLINE_VISIBILITY 767 char 768 basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const 769 { 770 return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault); 771 } 772 773 template <class _CharT, class _Traits> 774 inline _LIBCPP_INLINE_VISIBILITY 775 _CharT 776 basic_ios<_CharT, _Traits>::widen(char __c) const 777 { 778 return use_facet<ctype<char_type> >(getloc()).widen(__c); 779 } 780 781 template <class _CharT, class _Traits> 782 inline _LIBCPP_INLINE_VISIBILITY 783 _CharT 784 basic_ios<_CharT, _Traits>::fill() const 785 { 786 if (traits_type::eq_int_type(traits_type::eof(), __fill_)) 787 __fill_ = widen(' '); 788 return __fill_; 789 } 790 791 template <class _CharT, class _Traits> 792 inline _LIBCPP_INLINE_VISIBILITY 793 _CharT 794 basic_ios<_CharT, _Traits>::fill(char_type __ch) 795 { 796 char_type __r = __fill_; 797 __fill_ = __ch; 798 return __r; 799 } 800 801 template <class _CharT, class _Traits> 802 basic_ios<_CharT, _Traits>& 803 basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) 804 { 805 if (this != &__rhs) 806 { 807 __call_callbacks(erase_event); 808 ios_base::copyfmt(__rhs); 809 __tie_ = __rhs.__tie_; 810 __fill_ = __rhs.__fill_; 811 __call_callbacks(copyfmt_event); 812 exceptions(__rhs.exceptions()); 813 } 814 return *this; 815 } 816 817 template <class _CharT, class _Traits> 818 inline _LIBCPP_INLINE_VISIBILITY 819 void 820 basic_ios<_CharT, _Traits>::move(basic_ios& __rhs) 821 { 822 ios_base::move(__rhs); 823 __tie_ = __rhs.__tie_; 824 __rhs.__tie_ = nullptr; 825 __fill_ = __rhs.__fill_; 826 } 827 828 template <class _CharT, class _Traits> 829 inline _LIBCPP_INLINE_VISIBILITY 830 void 831 basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT 832 { 833 ios_base::swap(__rhs); 834 _VSTD::swap(__tie_, __rhs.__tie_); 835 _VSTD::swap(__fill_, __rhs.__fill_); 836 } 837 838 template <class _CharT, class _Traits> 839 inline _LIBCPP_INLINE_VISIBILITY 840 void 841 basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb) 842 { 843 ios_base::set_rdbuf(__sb); 844 } 845 846 inline 847 ios_base& 848 boolalpha(ios_base& __str) 849 { 850 __str.setf(ios_base::boolalpha); 851 return __str; 852 } 853 854 inline 855 ios_base& 856 noboolalpha(ios_base& __str) 857 { 858 __str.unsetf(ios_base::boolalpha); 859 return __str; 860 } 861 862 inline 863 ios_base& 864 showbase(ios_base& __str) 865 { 866 __str.setf(ios_base::showbase); 867 return __str; 868 } 869 870 inline 871 ios_base& 872 noshowbase(ios_base& __str) 873 { 874 __str.unsetf(ios_base::showbase); 875 return __str; 876 } 877 878 inline 879 ios_base& 880 showpoint(ios_base& __str) 881 { 882 __str.setf(ios_base::showpoint); 883 return __str; 884 } 885 886 inline 887 ios_base& 888 noshowpoint(ios_base& __str) 889 { 890 __str.unsetf(ios_base::showpoint); 891 return __str; 892 } 893 894 inline 895 ios_base& 896 showpos(ios_base& __str) 897 { 898 __str.setf(ios_base::showpos); 899 return __str; 900 } 901 902 inline 903 ios_base& 904 noshowpos(ios_base& __str) 905 { 906 __str.unsetf(ios_base::showpos); 907 return __str; 908 } 909 910 inline 911 ios_base& 912 skipws(ios_base& __str) 913 { 914 __str.setf(ios_base::skipws); 915 return __str; 916 } 917 918 inline 919 ios_base& 920 noskipws(ios_base& __str) 921 { 922 __str.unsetf(ios_base::skipws); 923 return __str; 924 } 925 926 inline 927 ios_base& 928 uppercase(ios_base& __str) 929 { 930 __str.setf(ios_base::uppercase); 931 return __str; 932 } 933 934 inline 935 ios_base& 936 nouppercase(ios_base& __str) 937 { 938 __str.unsetf(ios_base::uppercase); 939 return __str; 940 } 941 942 inline 943 ios_base& 944 unitbuf(ios_base& __str) 945 { 946 __str.setf(ios_base::unitbuf); 947 return __str; 948 } 949 950 inline 951 ios_base& 952 nounitbuf(ios_base& __str) 953 { 954 __str.unsetf(ios_base::unitbuf); 955 return __str; 956 } 957 958 inline 959 ios_base& 960 internal(ios_base& __str) 961 { 962 __str.setf(ios_base::internal, ios_base::adjustfield); 963 return __str; 964 } 965 966 inline 967 ios_base& 968 left(ios_base& __str) 969 { 970 __str.setf(ios_base::left, ios_base::adjustfield); 971 return __str; 972 } 973 974 inline 975 ios_base& 976 right(ios_base& __str) 977 { 978 __str.setf(ios_base::right, ios_base::adjustfield); 979 return __str; 980 } 981 982 inline 983 ios_base& 984 dec(ios_base& __str) 985 { 986 __str.setf(ios_base::dec, ios_base::basefield); 987 return __str; 988 } 989 990 inline 991 ios_base& 992 hex(ios_base& __str) 993 { 994 __str.setf(ios_base::hex, ios_base::basefield); 995 return __str; 996 } 997 998 inline 999 ios_base& 1000 oct(ios_base& __str) 1001 { 1002 __str.setf(ios_base::oct, ios_base::basefield); 1003 return __str; 1004 } 1005 1006 inline 1007 ios_base& 1008 fixed(ios_base& __str) 1009 { 1010 __str.setf(ios_base::fixed, ios_base::floatfield); 1011 return __str; 1012 } 1013 1014 inline 1015 ios_base& 1016 scientific(ios_base& __str) 1017 { 1018 __str.setf(ios_base::scientific, ios_base::floatfield); 1019 return __str; 1020 } 1021 1022 inline 1023 ios_base& 1024 hexfloat(ios_base& __str) 1025 { 1026 __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); 1027 return __str; 1028 } 1029 1030 inline 1031 ios_base& 1032 defaultfloat(ios_base& __str) 1033 { 1034 __str.unsetf(ios_base::floatfield); 1035 return __str; 1036 } 1037 1038 _LIBCPP_END_NAMESPACE_STD 1039 1040 #endif // _LIBCPP_IOS 1041
Indexes created Sun Oct 25 00:26:45 UTC 2026