| 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-exception |
| 7 |
// |
| 8 |
//===----------------------------------------------------------------------===// |
| 9 |
|
| 10 |
#ifndef _LIBCPP___CXX03_IOS |
| 11 |
#define _LIBCPP___CXX03_IOS |
| 12 |
|
| 13 |
/* |
| 14 |
ios synopsis |
| 15 |
|
| 16 |
#include <__cxx03/iosfwd> |
| 17 |
|
| 18 |
namespace std |
| 19 |
{ |
| 20 |
|
| 21 |
typedef OFF_T streamoff; |
| 22 |
typedef SZ_T streamsize; |
| 23 |
template <class stateT> class fpos; |
| 24 |
|
| 25 |
class ios_base |
| 26 |
{ |
| 27 |
public: |
| 28 |
class failure; |
| 29 |
|
| 30 |
typedef T1 fmtflags; |
| 31 |
static constexpr fmtflags boolalpha; |
| 32 |
static constexpr fmtflags dec; |
| 33 |
static constexpr fmtflags fixed; |
| 34 |
static constexpr fmtflags hex; |
| 35 |
static constexpr fmtflags internal; |
| 36 |
static constexpr fmtflags left; |
| 37 |
static constexpr fmtflags oct; |
| 38 |
static constexpr fmtflags right; |
| 39 |
static constexpr fmtflags scientific; |
| 40 |
static constexpr fmtflags showbase; |
| 41 |
static constexpr fmtflags showpoint; |
| 42 |
static constexpr fmtflags showpos; |
| 43 |
static constexpr fmtflags skipws; |
| 44 |
static constexpr fmtflags unitbuf; |
| 45 |
static constexpr fmtflags uppercase; |
| 46 |
static constexpr fmtflags adjustfield; |
| 47 |
static constexpr fmtflags basefield; |
| 48 |
static constexpr fmtflags floatfield; |
| 49 |
|
| 50 |
typedef T2 iostate; |
| 51 |
static constexpr iostate badbit; |
| 52 |
static constexpr iostate eofbit; |
| 53 |
static constexpr iostate failbit; |
| 54 |
static constexpr iostate goodbit; |
| 55 |
|
| 56 |
typedef T3 openmode; |
| 57 |
static constexpr openmode app; |
| 58 |
static constexpr openmode ate; |
| 59 |
static constexpr openmode binary; |
| 60 |
static constexpr openmode in; |
| 61 |
static constexpr openmode noreplace; // since C++23 |
| 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 |
|
| 106 |
protected: |
| 107 |
ios_base(); |
| 108 |
}; |
| 109 |
|
| 110 |
template <class charT, class traits = char_traits<charT> > |
| 111 |
class basic_ios |
| 112 |
: public ios_base |
| 113 |
{ |
| 114 |
public: |
| 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 |
|
| 159 |
protected: |
| 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: |
| 168 |
ios_base& boolalpha (ios_base& str); |
| 169 |
ios_base& noboolalpha(ios_base& str); |
| 170 |
ios_base& showbase (ios_base& str); |
| 171 |
ios_base& noshowbase (ios_base& str); |
| 172 |
ios_base& showpoint (ios_base& str); |
| 173 |
ios_base& noshowpoint(ios_base& str); |
| 174 |
ios_base& showpos (ios_base& str); |
| 175 |
ios_base& noshowpos (ios_base& str); |
| 176 |
ios_base& skipws (ios_base& str); |
| 177 |
ios_base& noskipws (ios_base& str); |
| 178 |
ios_base& uppercase (ios_base& str); |
| 179 |
ios_base& nouppercase(ios_base& str); |
| 180 |
ios_base& unitbuf (ios_base& str); |
| 181 |
ios_base& nounitbuf (ios_base& str); |
| 182 |
|
| 183 |
// 27.5.5.2 adjustfield: |
| 184 |
ios_base& internal (ios_base& str); |
| 185 |
ios_base& left (ios_base& str); |
| 186 |
ios_base& right (ios_base& str); |
| 187 |
|
| 188 |
// 27.5.5.3 basefield: |
| 189 |
ios_base& dec (ios_base& str); |
| 190 |
ios_base& hex (ios_base& str); |
| 191 |
ios_base& oct (ios_base& str); |
| 192 |
|
| 193 |
// 27.5.5.4 floatfield: |
| 194 |
ios_base& fixed (ios_base& str); |
| 195 |
ios_base& scientific (ios_base& str); |
| 196 |
ios_base& hexfloat (ios_base& str); |
| 197 |
ios_base& defaultfloat(ios_base& str); |
| 198 |
|
| 199 |
// 27.5.5.5 error reporting: |
| 200 |
enum class io_errc |
| 201 |
{ |
| 202 |
stream = 1 |
| 203 |
}; |
| 204 |
|
| 205 |
concept_map ErrorCodeEnum<io_errc> { }; |
| 206 |
error_code make_error_code(io_errc e) noexcept; |
| 207 |
error_condition make_error_condition(io_errc e) noexcept; |
| 208 |
storage-class-specifier const error_category& iostream_category() noexcept; |
| 209 |
|
| 210 |
} // std |
| 211 |
|
| 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 includes |
| 231 |
|
| 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 |
# endif |
| 238 |
|
| 239 |
# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| 240 |
# pragma GCC system_header |
| 241 |
# endif |
| 242 |
|
| 243 |
_LIBCPP_PUSH_MACROS |
| 244 |
# include <__cxx03/__undef_macros> |
| 245 |
|
| 246 |
_LIBCPP_BEGIN_NAMESPACE_STD |
| 247 |
|
| 248 |
typedef ptrdiff_t streamsize; |
| 249 |
|
| 250 |
class _LIBCPP_EXPORTED_FROM_ABI ios_base { |
| 251 |
public: |
| 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 |
// destructor |
| 321 |
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 |
else |
| 352 |
__rdstate_ |= __state | ios_base::badbit; |
| 353 |
} |
| 354 |
|
| 355 |
protected: |
| 356 |
_LIBCPP_HIDE_FROM_ABI ios_base() : __loc_(nullptr) { |
| 357 |
// Purposefully does no initialization |
| 358 |
// |
| 359 |
// Except for the locale, this is a sentinel to avoid destroying |
| 360 |
// an uninitialized object. See |
| 361 |
// test/libcxx/input.output/iostreams.base/ios.base/ios.base.cons/dtor.uninitialized.pass.cpp |
| 362 |
// 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 |
|
| 380 |
private: |
| 381 |
// All data members must be scalars |
| 382 |
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 only |
| 394 |
// enabled with clang. |
| 395 |
# if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS) |
| 396 |
static atomic<int> __xindex_; |
| 397 |
# else |
| 398 |
static int __xindex_; |
| 399 |
# endif |
| 400 |
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_errc |
| 409 |
_LIBCPP_DECLARE_STRONG_ENUM(io_errc){stream = 1}; |
| 410 |
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc) |
| 411 |
|
| 412 |
template <> |
| 413 |
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type {}; |
| 414 |
|
| 415 |
template <> |
| 416 |
struct _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 |
|
| 420 |
inline _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 |
|
| 424 |
inline _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 |
|
| 428 |
class _LIBCPP_EXPORTED_FROM_ABI ios_base::failure : public system_error { |
| 429 |
public: |
| 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_EXCEPTIONS |
| 438 |
throw ios_base::failure(__msg); |
| 439 |
# else |
| 440 |
_LIBCPP_VERBOSE_ABORT("ios_base::failure was thrown in -fno-exceptions mode with message \"%s\"", __msg); |
| 441 |
# endif |
| 442 |
} |
| 443 |
|
| 444 |
class _LIBCPP_EXPORTED_FROM_ABI ios_base::Init { |
| 445 |
public: |
| 446 |
Init(); |
| 447 |
~Init(); |
| 448 |
}; |
| 449 |
|
| 450 |
// fmtflags |
| 451 |
|
| 452 |
inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::flags() const { return __fmtflags_; } |
| 453 |
|
| 454 |
inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::flags(fmtflags __fmtfl) { |
| 455 |
fmtflags __r = __fmtflags_; |
| 456 |
__fmtflags_ = __fmtfl; |
| 457 |
return __r; |
| 458 |
} |
| 459 |
|
| 460 |
inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::setf(fmtflags __fmtfl) { |
| 461 |
fmtflags __r = __fmtflags_; |
| 462 |
__fmtflags_ |= __fmtfl; |
| 463 |
return __r; |
| 464 |
} |
| 465 |
|
| 466 |
inline _LIBCPP_HIDE_FROM_ABI void ios_base::unsetf(fmtflags __mask) { __fmtflags_ &= ~__mask; } |
| 467 |
|
| 468 |
inline _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 |
// precision |
| 476 |
|
| 477 |
inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::precision() const { return __precision_; } |
| 478 |
|
| 479 |
inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::precision(streamsize __prec) { |
| 480 |
streamsize __r = __precision_; |
| 481 |
__precision_ = __prec; |
| 482 |
return __r; |
| 483 |
} |
| 484 |
|
| 485 |
// width |
| 486 |
|
| 487 |
inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::width() const { return __width_; } |
| 488 |
|
| 489 |
inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::width(streamsize __wide) { |
| 490 |
streamsize __r = __width_; |
| 491 |
__width_ = __wide; |
| 492 |
return __r; |
| 493 |
} |
| 494 |
|
| 495 |
// iostate |
| 496 |
|
| 497 |
inline _LIBCPP_HIDE_FROM_ABI ios_base::iostate ios_base::rdstate() const { return __rdstate_; } |
| 498 |
|
| 499 |
inline _LIBCPP_HIDE_FROM_ABI void ios_base::setstate(iostate __state) { clear(__rdstate_ | __state); } |
| 500 |
|
| 501 |
inline _LIBCPP_HIDE_FROM_ABI bool ios_base::good() const { return __rdstate_ == 0; } |
| 502 |
|
| 503 |
inline _LIBCPP_HIDE_FROM_ABI bool ios_base::eof() const { return (__rdstate_ & eofbit) != 0; } |
| 504 |
|
| 505 |
inline _LIBCPP_HIDE_FROM_ABI bool ios_base::fail() const { return (__rdstate_ & (failbit | badbit)) != 0; } |
| 506 |
|
| 507 |
inline _LIBCPP_HIDE_FROM_ABI bool ios_base::bad() const { return (__rdstate_ & badbit) != 0; } |
| 508 |
|
| 509 |
inline _LIBCPP_HIDE_FROM_ABI ios_base::iostate ios_base::exceptions() const { return __exceptions_; } |
| 510 |
|
| 511 |
inline _LIBCPP_HIDE_FROM_ABI void ios_base::exceptions(iostate __iostate) { |
| 512 |
__exceptions_ = __iostate; |
| 513 |
clear(__rdstate_); |
| 514 |
} |
| 515 |
|
| 516 |
template <class _Traits> |
| 517 |
// Attribute 'packed' is used to keep the layout compatible with the previous |
| 518 |
// definition of the '__fill_' and '_set_' pair in basic_ios on AIX & z/OS. |
| 519 |
struct _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 |
|
| 529 |
private: |
| 530 |
typename _Traits::int_type __fill_val_; |
| 531 |
bool __set_; |
| 532 |
}; |
| 533 |
|
| 534 |
template <class _Traits> |
| 535 |
struct _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 |
|
| 544 |
private: |
| 545 |
typename _Traits::int_type __fill_val_; |
| 546 |
}; |
| 547 |
|
| 548 |
template <class _CharT, class _Traits> |
| 549 |
class _LIBCPP_TEMPLATE_VIS basic_ios : public ios_base { |
| 550 |
public: |
| 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 |
|
| 599 |
protected: |
| 600 |
_LIBCPP_HIDE_FROM_ABI basic_ios() { |
| 601 |
// purposefully does no initialization |
| 602 |
// 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 |
|
| 611 |
private: |
| 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 |
# else |
| 617 |
using _FillType = _SentinelValueFill<traits_type>; |
| 618 |
# endif |
| 619 |
mutable _FillType __fill_; |
| 620 |
}; |
| 621 |
|
| 622 |
template <class _CharT, class _Traits> |
| 623 |
inline _LIBCPP_HIDE_FROM_ABI basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type, traits_type>* __sb) { |
| 624 |
init(__sb); |
| 625 |
} |
| 626 |
|
| 627 |
template <class _CharT, class _Traits> |
| 628 |
basic_ios<_CharT, _Traits>::~basic_ios() {} |
| 629 |
|
| 630 |
template <class _CharT, class _Traits> |
| 631 |
inline _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 |
|
| 637 |
template <class _CharT, class _Traits> |
| 638 |
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>* basic_ios<_CharT, _Traits>::tie() const { |
| 639 |
return __tie_; |
| 640 |
} |
| 641 |
|
| 642 |
template <class _CharT, class _Traits> |
| 643 |
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>* |
| 644 |
basic_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 |
|
| 650 |
template <class _CharT, class _Traits> |
| 651 |
inline _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 |
|
| 655 |
template <class _CharT, class _Traits> |
| 656 |
inline _LIBCPP_HIDE_FROM_ABI basic_streambuf<_CharT, _Traits>* |
| 657 |
basic_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 |
|
| 663 |
template <class _CharT, class _Traits> |
| 664 |
inline _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 |
|
| 672 |
template <class _CharT, class _Traits> |
| 673 |
inline _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 |
|
| 677 |
template <class _CharT, class _Traits> |
| 678 |
inline _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 |
|
| 682 |
template <class _CharT, class _Traits> |
| 683 |
inline _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 |
|
| 689 |
template <class _CharT, class _Traits> |
| 690 |
inline _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 |
|
| 698 |
template <class _CharT, class _Traits> |
| 699 |
basic_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 |
|
| 711 |
template <class _CharT, class _Traits> |
| 712 |
inline _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 |
|
| 719 |
template <class _CharT, class _Traits> |
| 720 |
inline _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 |
|
| 726 |
template <class _CharT, class _Traits> |
| 727 |
inline _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 |
|
| 731 |
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<char>; |
| 732 |
|
| 733 |
# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS |
| 734 |
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t>; |
| 735 |
# endif |
| 736 |
|
| 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_STD |
| 858 |
|
| 859 |
_LIBCPP_POP_MACROS |
| 860 |
|
| 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 |
#endif |
| 876 |
|
| 877 |
#endif // _LIBCPP___CXX03_IOS |