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