ios revision 303975
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_TYPE_VIS 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_TYPE_VIS_ONLY is_error_code_enum<io_errc> : public true_type { }; 397 398#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 399template <> 400struct _LIBCPP_TYPE_VIS_ONLY 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 575template <class _CharT, class _Traits> 576class _LIBCPP_TYPE_VIS_ONLY basic_ios 577 : public ios_base 578{ 579public: 580 // types: 581 typedef _CharT char_type; 582 typedef _Traits traits_type; 583 584 typedef typename traits_type::int_type int_type; 585 typedef typename traits_type::pos_type pos_type; 586 typedef typename traits_type::off_type off_type; 587 588 _LIBCPP_ALWAYS_INLINE 589 _LIBCPP_EXPLICIT 590 operator bool() const {return !fail();} 591 _LIBCPP_ALWAYS_INLINE bool operator!() const {return fail();} 592 _LIBCPP_ALWAYS_INLINE iostate rdstate() const {return ios_base::rdstate();} 593 _LIBCPP_ALWAYS_INLINE void clear(iostate __state = goodbit) {ios_base::clear(__state);} 594 _LIBCPP_ALWAYS_INLINE void setstate(iostate __state) {ios_base::setstate(__state);} 595 _LIBCPP_ALWAYS_INLINE bool good() const {return ios_base::good();} 596 _LIBCPP_ALWAYS_INLINE bool eof() const {return ios_base::eof();} 597 _LIBCPP_ALWAYS_INLINE bool fail() const {return ios_base::fail();} 598 _LIBCPP_ALWAYS_INLINE bool bad() const {return ios_base::bad();} 599 600 _LIBCPP_ALWAYS_INLINE iostate exceptions() const {return ios_base::exceptions();} 601 _LIBCPP_ALWAYS_INLINE void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);} 602 603 // 27.5.4.1 Constructor/destructor: 604 _LIBCPP_INLINE_VISIBILITY 605 explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb); 606 virtual ~basic_ios(); 607 608 // 27.5.4.2 Members: 609 _LIBCPP_INLINE_VISIBILITY 610 basic_ostream<char_type, traits_type>* tie() const; 611 _LIBCPP_INLINE_VISIBILITY 612 basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr); 613 614 _LIBCPP_INLINE_VISIBILITY 615 basic_streambuf<char_type, traits_type>* rdbuf() const; 616 _LIBCPP_INLINE_VISIBILITY 617 basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb); 618 619 basic_ios& copyfmt(const basic_ios& __rhs); 620 621 _LIBCPP_INLINE_VISIBILITY 622 char_type fill() const; 623 _LIBCPP_INLINE_VISIBILITY 624 char_type fill(char_type __ch); 625 626 _LIBCPP_INLINE_VISIBILITY 627 locale imbue(const locale& __loc); 628 629 _LIBCPP_INLINE_VISIBILITY 630 char narrow(char_type __c, char __dfault) const; 631 _LIBCPP_INLINE_VISIBILITY 632 char_type widen(char __c) const; 633 634protected: 635 _LIBCPP_ALWAYS_INLINE 636 basic_ios() {// purposefully does no initialization 637 } 638 _LIBCPP_INLINE_VISIBILITY 639 void init(basic_streambuf<char_type, traits_type>* __sb); 640 641 _LIBCPP_INLINE_VISIBILITY 642 void move(basic_ios& __rhs); 643#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 644 _LIBCPP_ALWAYS_INLINE 645 void move(basic_ios&& __rhs) {move(__rhs);} 646#endif 647 _LIBCPP_INLINE_VISIBILITY 648 void swap(basic_ios& __rhs) _NOEXCEPT; 649 _LIBCPP_INLINE_VISIBILITY 650 void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb); 651private: 652 basic_ostream<char_type, traits_type>* __tie_; 653 mutable int_type __fill_; 654}; 655 656template <class _CharT, class _Traits> 657inline _LIBCPP_INLINE_VISIBILITY 658basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb) 659{ 660 init(__sb); 661} 662 663template <class _CharT, class _Traits> 664basic_ios<_CharT, _Traits>::~basic_ios() 665{ 666} 667 668template <class _CharT, class _Traits> 669inline _LIBCPP_INLINE_VISIBILITY 670void 671basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb) 672{ 673 ios_base::init(__sb); 674 __tie_ = 0; 675 __fill_ = traits_type::eof(); 676} 677 678template <class _CharT, class _Traits> 679inline _LIBCPP_INLINE_VISIBILITY 680basic_ostream<_CharT, _Traits>* 681basic_ios<_CharT, _Traits>::tie() const 682{ 683 return __tie_; 684} 685 686template <class _CharT, class _Traits> 687inline _LIBCPP_INLINE_VISIBILITY 688basic_ostream<_CharT, _Traits>* 689basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr) 690{ 691 basic_ostream<char_type, traits_type>* __r = __tie_; 692 __tie_ = __tiestr; 693 return __r; 694} 695 696template <class _CharT, class _Traits> 697inline _LIBCPP_INLINE_VISIBILITY 698basic_streambuf<_CharT, _Traits>* 699basic_ios<_CharT, _Traits>::rdbuf() const 700{ 701 return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf()); 702} 703 704template <class _CharT, class _Traits> 705inline _LIBCPP_INLINE_VISIBILITY 706basic_streambuf<_CharT, _Traits>* 707basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb) 708{ 709 basic_streambuf<char_type, traits_type>* __r = rdbuf(); 710 ios_base::rdbuf(__sb); 711 return __r; 712} 713 714template <class _CharT, class _Traits> 715inline _LIBCPP_INLINE_VISIBILITY 716locale 717basic_ios<_CharT, _Traits>::imbue(const locale& __loc) 718{ 719 locale __r = getloc(); 720 ios_base::imbue(__loc); 721 if (rdbuf()) 722 rdbuf()->pubimbue(__loc); 723 return __r; 724} 725 726template <class _CharT, class _Traits> 727inline _LIBCPP_INLINE_VISIBILITY 728char 729basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const 730{ 731 return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault); 732} 733 734template <class _CharT, class _Traits> 735inline _LIBCPP_INLINE_VISIBILITY 736_CharT 737basic_ios<_CharT, _Traits>::widen(char __c) const 738{ 739 return use_facet<ctype<char_type> >(getloc()).widen(__c); 740} 741 742template <class _CharT, class _Traits> 743inline _LIBCPP_INLINE_VISIBILITY 744_CharT 745basic_ios<_CharT, _Traits>::fill() const 746{ 747 if (traits_type::eq_int_type(traits_type::eof(), __fill_)) 748 __fill_ = widen(' '); 749 return __fill_; 750} 751 752template <class _CharT, class _Traits> 753inline _LIBCPP_INLINE_VISIBILITY 754_CharT 755basic_ios<_CharT, _Traits>::fill(char_type __ch) 756{ 757 char_type __r = __fill_; 758 __fill_ = __ch; 759 return __r; 760} 761 762template <class _CharT, class _Traits> 763basic_ios<_CharT, _Traits>& 764basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) 765{ 766 if (this != &__rhs) 767 { 768 __call_callbacks(erase_event); 769 ios_base::copyfmt(__rhs); 770 __tie_ = __rhs.__tie_; 771 __fill_ = __rhs.__fill_; 772 __call_callbacks(copyfmt_event); 773 exceptions(__rhs.exceptions()); 774 } 775 return *this; 776} 777 778template <class _CharT, class _Traits> 779inline _LIBCPP_INLINE_VISIBILITY 780void 781basic_ios<_CharT, _Traits>::move(basic_ios& __rhs) 782{ 783 ios_base::move(__rhs); 784 __tie_ = __rhs.__tie_; 785 __rhs.__tie_ = 0; 786 __fill_ = __rhs.__fill_; 787} 788 789template <class _CharT, class _Traits> 790inline _LIBCPP_INLINE_VISIBILITY 791void 792basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT 793{ 794 ios_base::swap(__rhs); 795 _VSTD::swap(__tie_, __rhs.__tie_); 796 _VSTD::swap(__fill_, __rhs.__fill_); 797} 798 799template <class _CharT, class _Traits> 800inline _LIBCPP_INLINE_VISIBILITY 801void 802basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb) 803{ 804 ios_base::set_rdbuf(__sb); 805} 806 807inline _LIBCPP_INLINE_VISIBILITY 808ios_base& 809boolalpha(ios_base& __str) 810{ 811 __str.setf(ios_base::boolalpha); 812 return __str; 813} 814 815inline _LIBCPP_INLINE_VISIBILITY 816ios_base& 817noboolalpha(ios_base& __str) 818{ 819 __str.unsetf(ios_base::boolalpha); 820 return __str; 821} 822 823inline _LIBCPP_INLINE_VISIBILITY 824ios_base& 825showbase(ios_base& __str) 826{ 827 __str.setf(ios_base::showbase); 828 return __str; 829} 830 831inline _LIBCPP_INLINE_VISIBILITY 832ios_base& 833noshowbase(ios_base& __str) 834{ 835 __str.unsetf(ios_base::showbase); 836 return __str; 837} 838 839inline _LIBCPP_INLINE_VISIBILITY 840ios_base& 841showpoint(ios_base& __str) 842{ 843 __str.setf(ios_base::showpoint); 844 return __str; 845} 846 847inline _LIBCPP_INLINE_VISIBILITY 848ios_base& 849noshowpoint(ios_base& __str) 850{ 851 __str.unsetf(ios_base::showpoint); 852 return __str; 853} 854 855inline _LIBCPP_INLINE_VISIBILITY 856ios_base& 857showpos(ios_base& __str) 858{ 859 __str.setf(ios_base::showpos); 860 return __str; 861} 862 863inline _LIBCPP_INLINE_VISIBILITY 864ios_base& 865noshowpos(ios_base& __str) 866{ 867 __str.unsetf(ios_base::showpos); 868 return __str; 869} 870 871inline _LIBCPP_INLINE_VISIBILITY 872ios_base& 873skipws(ios_base& __str) 874{ 875 __str.setf(ios_base::skipws); 876 return __str; 877} 878 879inline _LIBCPP_INLINE_VISIBILITY 880ios_base& 881noskipws(ios_base& __str) 882{ 883 __str.unsetf(ios_base::skipws); 884 return __str; 885} 886 887inline _LIBCPP_INLINE_VISIBILITY 888ios_base& 889uppercase(ios_base& __str) 890{ 891 __str.setf(ios_base::uppercase); 892 return __str; 893} 894 895inline _LIBCPP_INLINE_VISIBILITY 896ios_base& 897nouppercase(ios_base& __str) 898{ 899 __str.unsetf(ios_base::uppercase); 900 return __str; 901} 902 903inline _LIBCPP_INLINE_VISIBILITY 904ios_base& 905unitbuf(ios_base& __str) 906{ 907 __str.setf(ios_base::unitbuf); 908 return __str; 909} 910 911inline _LIBCPP_INLINE_VISIBILITY 912ios_base& 913nounitbuf(ios_base& __str) 914{ 915 __str.unsetf(ios_base::unitbuf); 916 return __str; 917} 918 919inline _LIBCPP_INLINE_VISIBILITY 920ios_base& 921internal(ios_base& __str) 922{ 923 __str.setf(ios_base::internal, ios_base::adjustfield); 924 return __str; 925} 926 927inline _LIBCPP_INLINE_VISIBILITY 928ios_base& 929left(ios_base& __str) 930{ 931 __str.setf(ios_base::left, ios_base::adjustfield); 932 return __str; 933} 934 935inline _LIBCPP_INLINE_VISIBILITY 936ios_base& 937right(ios_base& __str) 938{ 939 __str.setf(ios_base::right, ios_base::adjustfield); 940 return __str; 941} 942 943inline _LIBCPP_INLINE_VISIBILITY 944ios_base& 945dec(ios_base& __str) 946{ 947 __str.setf(ios_base::dec, ios_base::basefield); 948 return __str; 949} 950 951inline _LIBCPP_INLINE_VISIBILITY 952ios_base& 953hex(ios_base& __str) 954{ 955 __str.setf(ios_base::hex, ios_base::basefield); 956 return __str; 957} 958 959inline _LIBCPP_INLINE_VISIBILITY 960ios_base& 961oct(ios_base& __str) 962{ 963 __str.setf(ios_base::oct, ios_base::basefield); 964 return __str; 965} 966 967inline _LIBCPP_INLINE_VISIBILITY 968ios_base& 969fixed(ios_base& __str) 970{ 971 __str.setf(ios_base::fixed, ios_base::floatfield); 972 return __str; 973} 974 975inline _LIBCPP_INLINE_VISIBILITY 976ios_base& 977scientific(ios_base& __str) 978{ 979 __str.setf(ios_base::scientific, ios_base::floatfield); 980 return __str; 981} 982 983inline _LIBCPP_INLINE_VISIBILITY 984ios_base& 985hexfloat(ios_base& __str) 986{ 987 __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); 988 return __str; 989} 990 991inline _LIBCPP_INLINE_VISIBILITY 992ios_base& 993defaultfloat(ios_base& __str) 994{ 995 __str.unsetf(ios_base::floatfield); 996 return __str; 997} 998 999template <class _CharT, class _Traits> 1000class __save_flags 1001{ 1002 typedef basic_ios<_CharT, _Traits> __stream_type; 1003 typedef typename __stream_type::fmtflags fmtflags; 1004 1005 __stream_type& __stream_; 1006 fmtflags __fmtflags_; 1007 _CharT __fill_; 1008 1009 __save_flags(const __save_flags&); 1010 __save_flags& operator=(const __save_flags&); 1011public: 1012 _LIBCPP_INLINE_VISIBILITY 1013 explicit __save_flags(__stream_type& __stream) 1014 : __stream_(__stream), 1015 __fmtflags_(__stream.flags()), 1016 __fill_(__stream.fill()) 1017 {} 1018 _LIBCPP_INLINE_VISIBILITY 1019 ~__save_flags() 1020 { 1021 __stream_.flags(__fmtflags_); 1022 __stream_.fill(__fill_); 1023 } 1024}; 1025 1026_LIBCPP_END_NAMESPACE_STD 1027 1028#endif // _LIBCPP_IOS 1029