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 18namespace std 19{ 20 21typedef OFF_T streamoff; 22typedef SZ_T streamsize; 23template <class stateT> class fpos; 24 25class ios_base 26{ 27public: 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 105protected: 106 ios_base(); 107}; 108 109template <class charT, class traits = char_traits<charT> > 110class basic_ios 111 : public ios_base 112{ 113public: 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 158protected: 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: 167ios_base& boolalpha (ios_base& str); 168ios_base& noboolalpha(ios_base& str); 169ios_base& showbase (ios_base& str); 170ios_base& noshowbase (ios_base& str); 171ios_base& showpoint (ios_base& str); 172ios_base& noshowpoint(ios_base& str); 173ios_base& showpos (ios_base& str); 174ios_base& noshowpos (ios_base& str); 175ios_base& skipws (ios_base& str); 176ios_base& noskipws (ios_base& str); 177ios_base& uppercase (ios_base& str); 178ios_base& nouppercase(ios_base& str); 179ios_base& unitbuf (ios_base& str); 180ios_base& nounitbuf (ios_base& str); 181 182// 27.5.5.2 adjustfield: 183ios_base& internal (ios_base& str); 184ios_base& left (ios_base& str); 185ios_base& right (ios_base& str); 186 187// 27.5.5.3 basefield: 188ios_base& dec (ios_base& str); 189ios_base& hex (ios_base& str); 190ios_base& oct (ios_base& str); 191 192// 27.5.5.4 floatfield: 193ios_base& fixed (ios_base& str); 194ios_base& scientific (ios_base& str); 195ios_base& hexfloat (ios_base& str); 196ios_base& defaultfloat(ios_base& str); 197 198// 27.5.5.5 error reporting: 199enum class io_errc 200{ 201 stream = 1 202}; 203 204concept_map ErrorCodeEnum<io_errc> { }; 205error_code make_error_code(io_errc e) noexcept; 206error_condition make_error_condition(io_errc e) noexcept; 207storage-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 228typedef ptrdiff_t streamsize; 229 230class _LIBCPP_TYPE_VIS ios_base 231{ 232public: 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 311private: 312 ios_base(const ios_base&); // = delete; 313 ios_base& operator=(const ios_base&); // = delete; 314 315public: 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 342protected: 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 368private: 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 403template <> 404struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { }; 405 406#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 407template <> 408struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { }; 409#endif 410 411_LIBCPP_FUNC_VIS 412const error_category& iostream_category() _NOEXCEPT; 413 414inline _LIBCPP_INLINE_VISIBILITY 415error_code 416make_error_code(io_errc __e) _NOEXCEPT 417{ 418 return error_code(static_cast<int>(__e), iostream_category()); 419} 420 421inline _LIBCPP_INLINE_VISIBILITY 422error_condition 423make_error_condition(io_errc __e) _NOEXCEPT 424{ 425 return error_condition(static_cast<int>(__e), iostream_category()); 426} 427 428class _LIBCPP_EXCEPTION_ABI ios_base::failure 429 : public system_error 430{ 431public: 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 439void __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 448class _LIBCPP_TYPE_VIS ios_base::Init 449{ 450public: 451 Init(); 452 ~Init(); 453}; 454 455// fmtflags 456 457inline _LIBCPP_INLINE_VISIBILITY 458ios_base::fmtflags 459ios_base::flags() const 460{ 461 return __fmtflags_; 462} 463 464inline _LIBCPP_INLINE_VISIBILITY 465ios_base::fmtflags 466ios_base::flags(fmtflags __fmtfl) 467{ 468 fmtflags __r = __fmtflags_; 469 __fmtflags_ = __fmtfl; 470 return __r; 471} 472 473inline _LIBCPP_INLINE_VISIBILITY 474ios_base::fmtflags 475ios_base::setf(fmtflags __fmtfl) 476{ 477 fmtflags __r = __fmtflags_; 478 __fmtflags_ |= __fmtfl; 479 return __r; 480} 481 482inline _LIBCPP_INLINE_VISIBILITY 483void 484ios_base::unsetf(fmtflags __mask) 485{ 486 __fmtflags_ &= ~__mask; 487} 488 489inline _LIBCPP_INLINE_VISIBILITY 490ios_base::fmtflags 491ios_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 501inline _LIBCPP_INLINE_VISIBILITY 502streamsize 503ios_base::precision() const 504{ 505 return __precision_; 506} 507 508inline _LIBCPP_INLINE_VISIBILITY 509streamsize 510ios_base::precision(streamsize __prec) 511{ 512 streamsize __r = __precision_; 513 __precision_ = __prec; 514 return __r; 515} 516 517// width 518 519inline _LIBCPP_INLINE_VISIBILITY 520streamsize 521ios_base::width() const 522{ 523 return __width_; 524} 525 526inline _LIBCPP_INLINE_VISIBILITY 527streamsize 528ios_base::width(streamsize __wide) 529{ 530 streamsize __r = __width_; 531 __width_ = __wide; 532 return __r; 533} 534 535// iostate 536 537inline _LIBCPP_INLINE_VISIBILITY 538ios_base::iostate 539ios_base::rdstate() const 540{ 541 return __rdstate_; 542} 543 544inline _LIBCPP_INLINE_VISIBILITY 545void 546ios_base::setstate(iostate __state) 547{ 548 clear(__rdstate_ | __state); 549} 550 551inline _LIBCPP_INLINE_VISIBILITY 552bool 553ios_base::good() const 554{ 555 return __rdstate_ == 0; 556} 557 558inline _LIBCPP_INLINE_VISIBILITY 559bool 560ios_base::eof() const 561{ 562 return (__rdstate_ & eofbit) != 0; 563} 564 565inline _LIBCPP_INLINE_VISIBILITY 566bool 567ios_base::fail() const 568{ 569 return (__rdstate_ & (failbit | badbit)) != 0; 570} 571 572inline _LIBCPP_INLINE_VISIBILITY 573bool 574ios_base::bad() const 575{ 576 return (__rdstate_ & badbit) != 0; 577} 578 579inline _LIBCPP_INLINE_VISIBILITY 580ios_base::iostate 581ios_base::exceptions() const 582{ 583 return __exceptions_; 584} 585 586inline _LIBCPP_INLINE_VISIBILITY 587void 588ios_base::exceptions(iostate __iostate) 589{ 590 __exceptions_ = __iostate; 591 clear(__rdstate_); 592} 593 594#if defined(_LIBCPP_CXX03_LANG) 595struct _LIBCPP_TYPE_VIS __cxx03_bool { 596 typedef void (__cxx03_bool::*__bool_type)(); 597 void __true_value() {} 598}; 599#endif 600 601template <class _CharT, class _Traits> 602class _LIBCPP_TEMPLATE_VIS basic_ios 603 : public ios_base 604{ 605public: 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 673protected: 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); 690private: 691 basic_ostream<char_type, traits_type>* __tie_; 692 mutable int_type __fill_; 693}; 694 695template <class _CharT, class _Traits> 696inline _LIBCPP_INLINE_VISIBILITY 697basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb) 698{ 699 init(__sb); 700} 701 702template <class _CharT, class _Traits> 703basic_ios<_CharT, _Traits>::~basic_ios() 704{ 705} 706 707template <class _CharT, class _Traits> 708inline _LIBCPP_INLINE_VISIBILITY 709void 710basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb) 711{ 712 ios_base::init(__sb); 713 __tie_ = 0; 714 __fill_ = traits_type::eof(); 715} 716 717template <class _CharT, class _Traits> 718inline _LIBCPP_INLINE_VISIBILITY 719basic_ostream<_CharT, _Traits>* 720basic_ios<_CharT, _Traits>::tie() const 721{ 722 return __tie_; 723} 724 725template <class _CharT, class _Traits> 726inline _LIBCPP_INLINE_VISIBILITY 727basic_ostream<_CharT, _Traits>* 728basic_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 735template <class _CharT, class _Traits> 736inline _LIBCPP_INLINE_VISIBILITY 737basic_streambuf<_CharT, _Traits>* 738basic_ios<_CharT, _Traits>::rdbuf() const 739{ 740 return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf()); 741} 742 743template <class _CharT, class _Traits> 744inline _LIBCPP_INLINE_VISIBILITY 745basic_streambuf<_CharT, _Traits>* 746basic_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 753template <class _CharT, class _Traits> 754inline _LIBCPP_INLINE_VISIBILITY 755locale 756basic_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 765template <class _CharT, class _Traits> 766inline _LIBCPP_INLINE_VISIBILITY 767char 768basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const 769{ 770 return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault); 771} 772 773template <class _CharT, class _Traits> 774inline _LIBCPP_INLINE_VISIBILITY 775_CharT 776basic_ios<_CharT, _Traits>::widen(char __c) const 777{ 778 return use_facet<ctype<char_type> >(getloc()).widen(__c); 779} 780 781template <class _CharT, class _Traits> 782inline _LIBCPP_INLINE_VISIBILITY 783_CharT 784basic_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 791template <class _CharT, class _Traits> 792inline _LIBCPP_INLINE_VISIBILITY 793_CharT 794basic_ios<_CharT, _Traits>::fill(char_type __ch) 795{ 796 char_type __r = __fill_; 797 __fill_ = __ch; 798 return __r; 799} 800 801template <class _CharT, class _Traits> 802basic_ios<_CharT, _Traits>& 803basic_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 817template <class _CharT, class _Traits> 818inline _LIBCPP_INLINE_VISIBILITY 819void 820basic_ios<_CharT, _Traits>::move(basic_ios& __rhs) 821{ 822 ios_base::move(__rhs); 823 __tie_ = __rhs.__tie_; 824 __rhs.__tie_ = 0; 825 __fill_ = __rhs.__fill_; 826} 827 828template <class _CharT, class _Traits> 829inline _LIBCPP_INLINE_VISIBILITY 830void 831basic_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 838template <class _CharT, class _Traits> 839inline _LIBCPP_INLINE_VISIBILITY 840void 841basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb) 842{ 843 ios_base::set_rdbuf(__sb); 844} 845 846inline 847ios_base& 848boolalpha(ios_base& __str) 849{ 850 __str.setf(ios_base::boolalpha); 851 return __str; 852} 853 854inline 855ios_base& 856noboolalpha(ios_base& __str) 857{ 858 __str.unsetf(ios_base::boolalpha); 859 return __str; 860} 861 862inline 863ios_base& 864showbase(ios_base& __str) 865{ 866 __str.setf(ios_base::showbase); 867 return __str; 868} 869 870inline 871ios_base& 872noshowbase(ios_base& __str) 873{ 874 __str.unsetf(ios_base::showbase); 875 return __str; 876} 877 878inline 879ios_base& 880showpoint(ios_base& __str) 881{ 882 __str.setf(ios_base::showpoint); 883 return __str; 884} 885 886inline 887ios_base& 888noshowpoint(ios_base& __str) 889{ 890 __str.unsetf(ios_base::showpoint); 891 return __str; 892} 893 894inline 895ios_base& 896showpos(ios_base& __str) 897{ 898 __str.setf(ios_base::showpos); 899 return __str; 900} 901 902inline 903ios_base& 904noshowpos(ios_base& __str) 905{ 906 __str.unsetf(ios_base::showpos); 907 return __str; 908} 909 910inline 911ios_base& 912skipws(ios_base& __str) 913{ 914 __str.setf(ios_base::skipws); 915 return __str; 916} 917 918inline 919ios_base& 920noskipws(ios_base& __str) 921{ 922 __str.unsetf(ios_base::skipws); 923 return __str; 924} 925 926inline 927ios_base& 928uppercase(ios_base& __str) 929{ 930 __str.setf(ios_base::uppercase); 931 return __str; 932} 933 934inline 935ios_base& 936nouppercase(ios_base& __str) 937{ 938 __str.unsetf(ios_base::uppercase); 939 return __str; 940} 941 942inline 943ios_base& 944unitbuf(ios_base& __str) 945{ 946 __str.setf(ios_base::unitbuf); 947 return __str; 948} 949 950inline 951ios_base& 952nounitbuf(ios_base& __str) 953{ 954 __str.unsetf(ios_base::unitbuf); 955 return __str; 956} 957 958inline 959ios_base& 960internal(ios_base& __str) 961{ 962 __str.setf(ios_base::internal, ios_base::adjustfield); 963 return __str; 964} 965 966inline 967ios_base& 968left(ios_base& __str) 969{ 970 __str.setf(ios_base::left, ios_base::adjustfield); 971 return __str; 972} 973 974inline 975ios_base& 976right(ios_base& __str) 977{ 978 __str.setf(ios_base::right, ios_base::adjustfield); 979 return __str; 980} 981 982inline 983ios_base& 984dec(ios_base& __str) 985{ 986 __str.setf(ios_base::dec, ios_base::basefield); 987 return __str; 988} 989 990inline 991ios_base& 992hex(ios_base& __str) 993{ 994 __str.setf(ios_base::hex, ios_base::basefield); 995 return __str; 996} 997 998inline 999ios_base& 1000oct(ios_base& __str) 1001{ 1002 __str.setf(ios_base::oct, ios_base::basefield); 1003 return __str; 1004} 1005 1006inline 1007ios_base& 1008fixed(ios_base& __str) 1009{ 1010 __str.setf(ios_base::fixed, ios_base::floatfield); 1011 return __str; 1012} 1013 1014inline 1015ios_base& 1016scientific(ios_base& __str) 1017{ 1018 __str.setf(ios_base::scientific, ios_base::floatfield); 1019 return __str; 1020} 1021 1022inline 1023ios_base& 1024hexfloat(ios_base& __str) 1025{ 1026 __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); 1027 return __str; 1028} 1029 1030inline 1031ios_base& 1032defaultfloat(ios_base& __str) 1033{ 1034 __str.unsetf(ios_base::floatfield); 1035 return __str; 1036} 1037 1038template <class _CharT, class _Traits> 1039class __save_flags 1040{ 1041 typedef basic_ios<_CharT, _Traits> __stream_type; 1042 typedef typename __stream_type::fmtflags fmtflags; 1043 1044 __stream_type& __stream_; 1045 fmtflags __fmtflags_; 1046 _CharT __fill_; 1047 1048 __save_flags(const __save_flags&); 1049 __save_flags& operator=(const __save_flags&); 1050public: 1051 _LIBCPP_INLINE_VISIBILITY 1052 explicit __save_flags(__stream_type& __stream) 1053 : __stream_(__stream), 1054 __fmtflags_(__stream.flags()), 1055 __fill_(__stream.fill()) 1056 {} 1057 _LIBCPP_INLINE_VISIBILITY 1058 ~__save_flags() 1059 { 1060 __stream_.flags(__fmtflags_); 1061 __stream_.fill(__fill_); 1062 } 1063}; 1064 1065_LIBCPP_END_NAMESPACE_STD 1066 1067#endif // _LIBCPP_IOS 1068