878 lines · plain
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP___CXX03_IOS11#define _LIBCPP___CXX03_IOS12 13/*14 ios synopsis15 16#include <__cxx03/iosfwd>17 18namespace std19{20 21typedef OFF_T streamoff;22typedef SZ_T streamsize;23template <class stateT> class fpos;24 25class ios_base26{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 noreplace; // since C++2362 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 // destructor94 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_ios112 : public ios_base113{114public:115 // types:116 typedef charT char_type;117 typedef typename traits::int_type int_type; // removed in C++17118 typedef typename traits::pos_type pos_type; // removed in C++17119 typedef typename traits::off_type off_type; // removed in C++17120 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_errc201{202 stream = 1203};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} // std211 212*/213 214#include <__cxx03/__config>215 216#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)217 218# include <__cxx03/__fwd/ios.h>219# include <__cxx03/__ios/fpos.h>220# include <__cxx03/__locale>221# include <__cxx03/__memory/addressof.h>222# include <__cxx03/__system_error/error_category.h>223# include <__cxx03/__system_error/error_code.h>224# include <__cxx03/__system_error/error_condition.h>225# include <__cxx03/__system_error/system_error.h>226# include <__cxx03/__utility/swap.h>227# include <__cxx03/__verbose_abort>228# include <__cxx03/version>229 230// standard-mandated includes231 232// [ios.syn]233# include <__cxx03/iosfwd>234 235# if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)236# include <__cxx03/__atomic/atomic.h> // for __xindex_237# endif238 239# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)240# pragma GCC system_header241# endif242 243_LIBCPP_PUSH_MACROS244# include <__cxx03/__undef_macros>245 246_LIBCPP_BEGIN_NAMESPACE_STD247 248typedef ptrdiff_t streamsize;249 250class _LIBCPP_EXPORTED_FROM_ABI ios_base {251public:252 class _LIBCPP_EXPORTED_FROM_ABI failure;253 254 typedef unsigned int fmtflags;255 static const fmtflags boolalpha = 0x0001;256 static const fmtflags dec = 0x0002;257 static const fmtflags fixed = 0x0004;258 static const fmtflags hex = 0x0008;259 static const fmtflags internal = 0x0010;260 static const fmtflags left = 0x0020;261 static const fmtflags oct = 0x0040;262 static const fmtflags right = 0x0080;263 static const fmtflags scientific = 0x0100;264 static const fmtflags showbase = 0x0200;265 static const fmtflags showpoint = 0x0400;266 static const fmtflags showpos = 0x0800;267 static const fmtflags skipws = 0x1000;268 static const fmtflags unitbuf = 0x2000;269 static const fmtflags uppercase = 0x4000;270 static const fmtflags adjustfield = left | right | internal;271 static const fmtflags basefield = dec | oct | hex;272 static const fmtflags floatfield = scientific | fixed;273 274 typedef unsigned int iostate;275 static const iostate badbit = 0x1;276 static const iostate eofbit = 0x2;277 static const iostate failbit = 0x4;278 static const iostate goodbit = 0x0;279 280 typedef unsigned int openmode;281 static const openmode app = 0x01;282 static const openmode ate = 0x02;283 static const openmode binary = 0x04;284 static const openmode in = 0x08;285 static const openmode out = 0x10;286 static const openmode trunc = 0x20;287 288 enum seekdir { beg, cur, end };289 290 typedef iostate io_state;291 typedef openmode open_mode;292 typedef seekdir seek_dir;293 294 typedef std::streamoff streamoff;295 typedef std::streampos streampos;296 297 class _LIBCPP_EXPORTED_FROM_ABI Init;298 299 // 27.5.2.2 fmtflags state:300 _LIBCPP_HIDE_FROM_ABI fmtflags flags() const;301 _LIBCPP_HIDE_FROM_ABI fmtflags flags(fmtflags __fmtfl);302 _LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl);303 _LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl, fmtflags __mask);304 _LIBCPP_HIDE_FROM_ABI void unsetf(fmtflags __mask);305 306 _LIBCPP_HIDE_FROM_ABI streamsize precision() const;307 _LIBCPP_HIDE_FROM_ABI streamsize precision(streamsize __prec);308 _LIBCPP_HIDE_FROM_ABI streamsize width() const;309 _LIBCPP_HIDE_FROM_ABI streamsize width(streamsize __wide);310 311 // 27.5.2.3 locales:312 locale imbue(const locale& __loc);313 locale getloc() const;314 315 // 27.5.2.5 storage:316 static int xalloc();317 long& iword(int __index);318 void*& pword(int __index);319 320 // destructor321 virtual ~ios_base();322 323 // 27.5.2.6 callbacks;324 enum event { erase_event, imbue_event, copyfmt_event };325 typedef void (*event_callback)(event, ios_base&, int __index);326 void register_callback(event_callback __fn, int __index);327 328 ios_base(const ios_base&) = delete;329 ios_base& operator=(const ios_base&) = delete;330 331 static bool sync_with_stdio(bool __sync = true);332 333 _LIBCPP_HIDE_FROM_ABI iostate rdstate() const;334 void clear(iostate __state = goodbit);335 _LIBCPP_HIDE_FROM_ABI void setstate(iostate __state);336 337 _LIBCPP_HIDE_FROM_ABI bool good() const;338 _LIBCPP_HIDE_FROM_ABI bool eof() const;339 _LIBCPP_HIDE_FROM_ABI bool fail() const;340 _LIBCPP_HIDE_FROM_ABI bool bad() const;341 342 _LIBCPP_HIDE_FROM_ABI iostate exceptions() const;343 _LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate);344 345 void __set_badbit_and_consider_rethrow();346 void __set_failbit_and_consider_rethrow();347 348 _LIBCPP_HIDE_FROM_ABI void __setstate_nothrow(iostate __state) {349 if (__rdbuf_)350 __rdstate_ |= __state;351 else352 __rdstate_ |= __state | ios_base::badbit;353 }354 355protected:356 _LIBCPP_HIDE_FROM_ABI ios_base() : __loc_(nullptr) {357 // Purposefully does no initialization358 //359 // Except for the locale, this is a sentinel to avoid destroying360 // an uninitialized object. See361 // test/libcxx/input.output/iostreams.base/ios.base/ios.base.cons/dtor.uninitialized.pass.cpp362 // for the details.363 }364 365 void init(void* __sb);366 _LIBCPP_HIDE_FROM_ABI void* rdbuf() const { return __rdbuf_; }367 368 _LIBCPP_HIDE_FROM_ABI void rdbuf(void* __sb) {369 __rdbuf_ = __sb;370 clear();371 }372 373 void __call_callbacks(event);374 void copyfmt(const ios_base&);375 void move(ios_base&);376 void swap(ios_base&) _NOEXCEPT;377 378 _LIBCPP_HIDE_FROM_ABI void set_rdbuf(void* __sb) { __rdbuf_ = __sb; }379 380private:381 // All data members must be scalars382 fmtflags __fmtflags_;383 streamsize __precision_;384 streamsize __width_;385 iostate __rdstate_;386 iostate __exceptions_;387 void* __rdbuf_;388 void* __loc_;389 event_callback* __fn_;390 int* __index_;391 size_t __event_size_;392 size_t __event_cap_;393// TODO(EricWF): Enable this for both Clang and GCC. Currently it is only394// enabled with clang.395# if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)396 static atomic<int> __xindex_;397# else398 static int __xindex_;399# endif400 long* __iarray_;401 size_t __iarray_size_;402 size_t __iarray_cap_;403 void** __parray_;404 size_t __parray_size_;405 size_t __parray_cap_;406};407 408// enum class io_errc409_LIBCPP_DECLARE_STRONG_ENUM(io_errc){stream = 1};410_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)411 412template <>413struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type {};414 415template <>416struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type {};417 418_LIBCPP_EXPORTED_FROM_ABI const error_category& iostream_category() _NOEXCEPT;419 420inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(io_errc __e) _NOEXCEPT {421 return error_code(static_cast<int>(__e), iostream_category());422}423 424inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(io_errc __e) _NOEXCEPT {425 return error_condition(static_cast<int>(__e), iostream_category());426}427 428class _LIBCPP_EXPORTED_FROM_ABI ios_base::failure : public system_error {429public:430 explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);431 explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);432 _LIBCPP_HIDE_FROM_ABI failure(const failure&) _NOEXCEPT = default;433 ~failure() _NOEXCEPT override;434};435 436_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_failure(char const* __msg) {437# ifndef _LIBCPP_HAS_NO_EXCEPTIONS438 throw ios_base::failure(__msg);439# else440 _LIBCPP_VERBOSE_ABORT("ios_base::failure was thrown in -fno-exceptions mode with message \"%s\"", __msg);441# endif442}443 444class _LIBCPP_EXPORTED_FROM_ABI ios_base::Init {445public:446 Init();447 ~Init();448};449 450// fmtflags451 452inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::flags() const { return __fmtflags_; }453 454inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::flags(fmtflags __fmtfl) {455 fmtflags __r = __fmtflags_;456 __fmtflags_ = __fmtfl;457 return __r;458}459 460inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::setf(fmtflags __fmtfl) {461 fmtflags __r = __fmtflags_;462 __fmtflags_ |= __fmtfl;463 return __r;464}465 466inline _LIBCPP_HIDE_FROM_ABI void ios_base::unsetf(fmtflags __mask) { __fmtflags_ &= ~__mask; }467 468inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::setf(fmtflags __fmtfl, fmtflags __mask) {469 fmtflags __r = __fmtflags_;470 unsetf(__mask);471 __fmtflags_ |= __fmtfl & __mask;472 return __r;473}474 475// precision476 477inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::precision() const { return __precision_; }478 479inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::precision(streamsize __prec) {480 streamsize __r = __precision_;481 __precision_ = __prec;482 return __r;483}484 485// width486 487inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::width() const { return __width_; }488 489inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::width(streamsize __wide) {490 streamsize __r = __width_;491 __width_ = __wide;492 return __r;493}494 495// iostate496 497inline _LIBCPP_HIDE_FROM_ABI ios_base::iostate ios_base::rdstate() const { return __rdstate_; }498 499inline _LIBCPP_HIDE_FROM_ABI void ios_base::setstate(iostate __state) { clear(__rdstate_ | __state); }500 501inline _LIBCPP_HIDE_FROM_ABI bool ios_base::good() const { return __rdstate_ == 0; }502 503inline _LIBCPP_HIDE_FROM_ABI bool ios_base::eof() const { return (__rdstate_ & eofbit) != 0; }504 505inline _LIBCPP_HIDE_FROM_ABI bool ios_base::fail() const { return (__rdstate_ & (failbit | badbit)) != 0; }506 507inline _LIBCPP_HIDE_FROM_ABI bool ios_base::bad() const { return (__rdstate_ & badbit) != 0; }508 509inline _LIBCPP_HIDE_FROM_ABI ios_base::iostate ios_base::exceptions() const { return __exceptions_; }510 511inline _LIBCPP_HIDE_FROM_ABI void ios_base::exceptions(iostate __iostate) {512 __exceptions_ = __iostate;513 clear(__rdstate_);514}515 516template <class _Traits>517// Attribute 'packed' is used to keep the layout compatible with the previous518// definition of the '__fill_' and '_set_' pair in basic_ios on AIX & z/OS.519struct _LIBCPP_PACKED _FillHelper {520 _LIBCPP_HIDE_FROM_ABI void __init() { __set_ = false; }521 _LIBCPP_HIDE_FROM_ABI _FillHelper& operator=(typename _Traits::int_type __x) {522 __set_ = true;523 __fill_val_ = __x;524 return *this;525 }526 _LIBCPP_HIDE_FROM_ABI bool __is_set() const { return __set_; }527 _LIBCPP_HIDE_FROM_ABI typename _Traits::int_type __get() const { return __fill_val_; }528 529private:530 typename _Traits::int_type __fill_val_;531 bool __set_;532};533 534template <class _Traits>535struct _LIBCPP_PACKED _SentinelValueFill {536 _LIBCPP_HIDE_FROM_ABI void __init() { __fill_val_ = _Traits::eof(); }537 _LIBCPP_HIDE_FROM_ABI _SentinelValueFill& operator=(typename _Traits::int_type __x) {538 __fill_val_ = __x;539 return *this;540 }541 _LIBCPP_HIDE_FROM_ABI bool __is_set() const { return __fill_val_ != _Traits::eof(); }542 _LIBCPP_HIDE_FROM_ABI typename _Traits::int_type __get() const { return __fill_val_; }543 544private:545 typename _Traits::int_type __fill_val_;546};547 548template <class _CharT, class _Traits>549class _LIBCPP_TEMPLATE_VIS basic_ios : public ios_base {550public:551 // types:552 typedef _CharT char_type;553 typedef _Traits traits_type;554 555 typedef typename traits_type::int_type int_type;556 typedef typename traits_type::pos_type pos_type;557 typedef typename traits_type::off_type off_type;558 559 static_assert(is_same<_CharT, typename traits_type::char_type>::value,560 "traits_type::char_type must be the same type as CharT");561 562 // Preserve the ability to compare with literal 0,563 // and implicitly convert to bool, but not implicitly convert to int.564 _LIBCPP_HIDE_FROM_ABI operator void*() const { return fail() ? nullptr : (void*)this; }565 566 _LIBCPP_HIDE_FROM_ABI bool operator!() const { return fail(); }567 _LIBCPP_HIDE_FROM_ABI iostate rdstate() const { return ios_base::rdstate(); }568 _LIBCPP_HIDE_FROM_ABI void clear(iostate __state = goodbit) { ios_base::clear(__state); }569 _LIBCPP_HIDE_FROM_ABI void setstate(iostate __state) { ios_base::setstate(__state); }570 _LIBCPP_HIDE_FROM_ABI bool good() const { return ios_base::good(); }571 _LIBCPP_HIDE_FROM_ABI bool eof() const { return ios_base::eof(); }572 _LIBCPP_HIDE_FROM_ABI bool fail() const { return ios_base::fail(); }573 _LIBCPP_HIDE_FROM_ABI bool bad() const { return ios_base::bad(); }574 575 _LIBCPP_HIDE_FROM_ABI iostate exceptions() const { return ios_base::exceptions(); }576 _LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate) { ios_base::exceptions(__iostate); }577 578 // 27.5.4.1 Constructor/destructor:579 _LIBCPP_HIDE_FROM_ABI explicit basic_ios(basic_streambuf<char_type, traits_type>* __sb);580 ~basic_ios() override;581 582 // 27.5.4.2 Members:583 _LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie() const;584 _LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);585 586 _LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf() const;587 _LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);588 589 basic_ios& copyfmt(const basic_ios& __rhs);590 591 _LIBCPP_HIDE_FROM_ABI char_type fill() const;592 _LIBCPP_HIDE_FROM_ABI char_type fill(char_type __ch);593 594 _LIBCPP_HIDE_FROM_ABI locale imbue(const locale& __loc);595 596 _LIBCPP_HIDE_FROM_ABI char narrow(char_type __c, char __dfault) const;597 _LIBCPP_HIDE_FROM_ABI char_type widen(char __c) const;598 599protected:600 _LIBCPP_HIDE_FROM_ABI basic_ios() {601 // purposefully does no initialization602 // since the destructor does nothing this does not have ios_base issues.603 }604 _LIBCPP_HIDE_FROM_ABI void init(basic_streambuf<char_type, traits_type>* __sb);605 606 _LIBCPP_HIDE_FROM_ABI void move(basic_ios& __rhs);607 _LIBCPP_HIDE_FROM_ABI void move(basic_ios&& __rhs) { move(__rhs); }608 _LIBCPP_HIDE_FROM_ABI void swap(basic_ios& __rhs) _NOEXCEPT;609 _LIBCPP_HIDE_FROM_ABI void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);610 611private:612 basic_ostream<char_type, traits_type>* __tie_;613 614# if defined(_LIBCPP_ABI_IOS_ALLOW_ARBITRARY_FILL_VALUE)615 using _FillType = _FillHelper<traits_type>;616# else617 using _FillType = _SentinelValueFill<traits_type>;618# endif619 mutable _FillType __fill_;620};621 622template <class _CharT, class _Traits>623inline _LIBCPP_HIDE_FROM_ABI basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type, traits_type>* __sb) {624 init(__sb);625}626 627template <class _CharT, class _Traits>628basic_ios<_CharT, _Traits>::~basic_ios() {}629 630template <class _CharT, class _Traits>631inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb) {632 ios_base::init(__sb);633 __tie_ = nullptr;634 __fill_.__init();635}636 637template <class _CharT, class _Traits>638inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>* basic_ios<_CharT, _Traits>::tie() const {639 return __tie_;640}641 642template <class _CharT, class _Traits>643inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>*644basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr) {645 basic_ostream<char_type, traits_type>* __r = __tie_;646 __tie_ = __tiestr;647 return __r;648}649 650template <class _CharT, class _Traits>651inline _LIBCPP_HIDE_FROM_ABI basic_streambuf<_CharT, _Traits>* basic_ios<_CharT, _Traits>::rdbuf() const {652 return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf());653}654 655template <class _CharT, class _Traits>656inline _LIBCPP_HIDE_FROM_ABI basic_streambuf<_CharT, _Traits>*657basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb) {658 basic_streambuf<char_type, traits_type>* __r = rdbuf();659 ios_base::rdbuf(__sb);660 return __r;661}662 663template <class _CharT, class _Traits>664inline _LIBCPP_HIDE_FROM_ABI locale basic_ios<_CharT, _Traits>::imbue(const locale& __loc) {665 locale __r = getloc();666 ios_base::imbue(__loc);667 if (rdbuf())668 rdbuf()->pubimbue(__loc);669 return __r;670}671 672template <class _CharT, class _Traits>673inline _LIBCPP_HIDE_FROM_ABI char basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const {674 return std::use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);675}676 677template <class _CharT, class _Traits>678inline _LIBCPP_HIDE_FROM_ABI _CharT basic_ios<_CharT, _Traits>::widen(char __c) const {679 return std::use_facet<ctype<char_type> >(getloc()).widen(__c);680}681 682template <class _CharT, class _Traits>683inline _LIBCPP_HIDE_FROM_ABI _CharT basic_ios<_CharT, _Traits>::fill() const {684 if (!__fill_.__is_set())685 __fill_ = widen(' ');686 return __fill_.__get();687}688 689template <class _CharT, class _Traits>690inline _LIBCPP_HIDE_FROM_ABI _CharT basic_ios<_CharT, _Traits>::fill(char_type __ch) {691 if (!__fill_.__is_set())692 __fill_ = widen(' ');693 char_type __r = __fill_.__get();694 __fill_ = __ch;695 return __r;696}697 698template <class _CharT, class _Traits>699basic_ios<_CharT, _Traits>& basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) {700 if (this != std::addressof(__rhs)) {701 __call_callbacks(erase_event);702 ios_base::copyfmt(__rhs);703 __tie_ = __rhs.__tie_;704 __fill_ = __rhs.__fill_;705 __call_callbacks(copyfmt_event);706 exceptions(__rhs.exceptions());707 }708 return *this;709}710 711template <class _CharT, class _Traits>712inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::move(basic_ios& __rhs) {713 ios_base::move(__rhs);714 __tie_ = __rhs.__tie_;715 __rhs.__tie_ = nullptr;716 __fill_ = __rhs.__fill_;717}718 719template <class _CharT, class _Traits>720inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT {721 ios_base::swap(__rhs);722 std::swap(__tie_, __rhs.__tie_);723 std::swap(__fill_, __rhs.__fill_);724}725 726template <class _CharT, class _Traits>727inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb) {728 ios_base::set_rdbuf(__sb);729}730 731extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<char>;732 733# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS734extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t>;735# endif736 737_LIBCPP_HIDE_FROM_ABI inline ios_base& boolalpha(ios_base& __str) {738 __str.setf(ios_base::boolalpha);739 return __str;740}741 742_LIBCPP_HIDE_FROM_ABI inline ios_base& noboolalpha(ios_base& __str) {743 __str.unsetf(ios_base::boolalpha);744 return __str;745}746 747_LIBCPP_HIDE_FROM_ABI inline ios_base& showbase(ios_base& __str) {748 __str.setf(ios_base::showbase);749 return __str;750}751 752_LIBCPP_HIDE_FROM_ABI inline ios_base& noshowbase(ios_base& __str) {753 __str.unsetf(ios_base::showbase);754 return __str;755}756 757_LIBCPP_HIDE_FROM_ABI inline ios_base& showpoint(ios_base& __str) {758 __str.setf(ios_base::showpoint);759 return __str;760}761 762_LIBCPP_HIDE_FROM_ABI inline ios_base& noshowpoint(ios_base& __str) {763 __str.unsetf(ios_base::showpoint);764 return __str;765}766 767_LIBCPP_HIDE_FROM_ABI inline ios_base& showpos(ios_base& __str) {768 __str.setf(ios_base::showpos);769 return __str;770}771 772_LIBCPP_HIDE_FROM_ABI inline ios_base& noshowpos(ios_base& __str) {773 __str.unsetf(ios_base::showpos);774 return __str;775}776 777_LIBCPP_HIDE_FROM_ABI inline ios_base& skipws(ios_base& __str) {778 __str.setf(ios_base::skipws);779 return __str;780}781 782_LIBCPP_HIDE_FROM_ABI inline ios_base& noskipws(ios_base& __str) {783 __str.unsetf(ios_base::skipws);784 return __str;785}786 787_LIBCPP_HIDE_FROM_ABI inline ios_base& uppercase(ios_base& __str) {788 __str.setf(ios_base::uppercase);789 return __str;790}791 792_LIBCPP_HIDE_FROM_ABI inline ios_base& nouppercase(ios_base& __str) {793 __str.unsetf(ios_base::uppercase);794 return __str;795}796 797_LIBCPP_HIDE_FROM_ABI inline ios_base& unitbuf(ios_base& __str) {798 __str.setf(ios_base::unitbuf);799 return __str;800}801 802_LIBCPP_HIDE_FROM_ABI inline ios_base& nounitbuf(ios_base& __str) {803 __str.unsetf(ios_base::unitbuf);804 return __str;805}806 807_LIBCPP_HIDE_FROM_ABI inline ios_base& internal(ios_base& __str) {808 __str.setf(ios_base::internal, ios_base::adjustfield);809 return __str;810}811 812_LIBCPP_HIDE_FROM_ABI inline ios_base& left(ios_base& __str) {813 __str.setf(ios_base::left, ios_base::adjustfield);814 return __str;815}816 817_LIBCPP_HIDE_FROM_ABI inline ios_base& right(ios_base& __str) {818 __str.setf(ios_base::right, ios_base::adjustfield);819 return __str;820}821 822_LIBCPP_HIDE_FROM_ABI inline ios_base& dec(ios_base& __str) {823 __str.setf(ios_base::dec, ios_base::basefield);824 return __str;825}826 827_LIBCPP_HIDE_FROM_ABI inline ios_base& hex(ios_base& __str) {828 __str.setf(ios_base::hex, ios_base::basefield);829 return __str;830}831 832_LIBCPP_HIDE_FROM_ABI inline ios_base& oct(ios_base& __str) {833 __str.setf(ios_base::oct, ios_base::basefield);834 return __str;835}836 837_LIBCPP_HIDE_FROM_ABI inline ios_base& fixed(ios_base& __str) {838 __str.setf(ios_base::fixed, ios_base::floatfield);839 return __str;840}841 842_LIBCPP_HIDE_FROM_ABI inline ios_base& scientific(ios_base& __str) {843 __str.setf(ios_base::scientific, ios_base::floatfield);844 return __str;845}846 847_LIBCPP_HIDE_FROM_ABI inline ios_base& hexfloat(ios_base& __str) {848 __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);849 return __str;850}851 852_LIBCPP_HIDE_FROM_ABI inline ios_base& defaultfloat(ios_base& __str) {853 __str.unsetf(ios_base::floatfield);854 return __str;855}856 857_LIBCPP_END_NAMESPACE_STD858 859_LIBCPP_POP_MACROS860 861#endif // !defined(_LIBCPP_HAS_NO_LOCALIZATION)862 863#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)864# include <__cxx03/atomic>865# include <__cxx03/cstddef>866# include <__cxx03/cstdlib>867# include <__cxx03/cstring>868# include <__cxx03/limits>869# include <__cxx03/mutex>870# include <__cxx03/new>871# include <__cxx03/stdexcept>872# include <__cxx03/system_error>873# include <__cxx03/type_traits>874# include <__cxx03/typeinfo>875#endif876 877#endif // _LIBCPP___CXX03_IOS878