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