File Coverage

/usr/include/c++/5/bits/ios_base.h
Criterion Covered Total %
statement 0 2 0.0
branch n/a
condition n/a
subroutine n/a
pod n/a
total 0 2 0.0


line stmt bran cond sub pod time code
1             // Iostreams base classes -*- C++ -*-
2              
3             // Copyright (C) 1997-2015 Free Software Foundation, Inc.
4             //
5             // This file is part of the GNU ISO C++ Library. This library is free
6             // software; you can redistribute it and/or modify it under the
7             // terms of the GNU General Public License as published by the
8             // Free Software Foundation; either version 3, or (at your option)
9             // any later version.
10              
11             // This library is distributed in the hope that it will be useful,
12             // but WITHOUT ANY WARRANTY; without even the implied warranty of
13             // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14             // GNU General Public License for more details.
15              
16             // Under Section 7 of GPL version 3, you are granted additional
17             // permissions described in the GCC Runtime Library Exception, version
18             // 3.1, as published by the Free Software Foundation.
19              
20             // You should have received a copy of the GNU General Public License and
21             // a copy of the GCC Runtime Library Exception along with this program;
22             // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23             // .
24              
25             /** @file bits/ios_base.h
26             * This is an internal header file, included by other library headers.
27             * Do not attempt to use it directly. @headername{ios}
28             */
29              
30             //
31             // ISO C++ 14882: 27.4 Iostreams base classes
32             //
33              
34             #ifndef _IOS_BASE_H
35             #define _IOS_BASE_H 1
36              
37             #pragma GCC system_header
38              
39             #include
40             #include
41             #include
42              
43             #if __cplusplus < 201103L
44             # include
45             #else
46             # include
47             #endif
48              
49             namespace std _GLIBCXX_VISIBILITY(default)
50             {
51             _GLIBCXX_BEGIN_NAMESPACE_VERSION
52              
53             // The following definitions of bitmask types are enums, not ints,
54             // as permitted (but not required) in the standard, in order to provide
55             // better type safety in iostream calls. A side effect is that
56             // expressions involving them are no longer compile-time constants.
57             enum _Ios_Fmtflags
58             {
59             _S_boolalpha = 1L << 0,
60             _S_dec = 1L << 1,
61             _S_fixed = 1L << 2,
62             _S_hex = 1L << 3,
63             _S_internal = 1L << 4,
64             _S_left = 1L << 5,
65             _S_oct = 1L << 6,
66             _S_right = 1L << 7,
67             _S_scientific = 1L << 8,
68             _S_showbase = 1L << 9,
69             _S_showpoint = 1L << 10,
70             _S_showpos = 1L << 11,
71             _S_skipws = 1L << 12,
72             _S_unitbuf = 1L << 13,
73             _S_uppercase = 1L << 14,
74             _S_adjustfield = _S_left | _S_right | _S_internal,
75             _S_basefield = _S_dec | _S_oct | _S_hex,
76             _S_floatfield = _S_scientific | _S_fixed,
77             _S_ios_fmtflags_end = 1L << 16,
78             _S_ios_fmtflags_max = __INT_MAX__,
79             _S_ios_fmtflags_min = ~__INT_MAX__
80             };
81              
82             inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
83             operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
84             { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); }
85              
86             inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
87             operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
88             { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); }
89              
90             inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
91             operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
92             { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); }
93              
94             inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
95             operator~(_Ios_Fmtflags __a)
96             { return _Ios_Fmtflags(~static_cast(__a)); }
97              
98             inline const _Ios_Fmtflags&
99             operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
100             { return __a = __a | __b; }
101              
102             inline const _Ios_Fmtflags&
103             operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
104             { return __a = __a & __b; }
105              
106             inline const _Ios_Fmtflags&
107             operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
108             { return __a = __a ^ __b; }
109              
110              
111             enum _Ios_Openmode
112             {
113             _S_app = 1L << 0,
114             _S_ate = 1L << 1,
115             _S_bin = 1L << 2,
116             _S_in = 1L << 3,
117             _S_out = 1L << 4,
118             _S_trunc = 1L << 5,
119             _S_ios_openmode_end = 1L << 16,
120             _S_ios_openmode_max = __INT_MAX__,
121             _S_ios_openmode_min = ~__INT_MAX__
122             };
123              
124             inline _GLIBCXX_CONSTEXPR _Ios_Openmode
125             operator&(_Ios_Openmode __a, _Ios_Openmode __b)
126             { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); }
127              
128             inline _GLIBCXX_CONSTEXPR _Ios_Openmode
129 0           operator|(_Ios_Openmode __a, _Ios_Openmode __b)
130 0           { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); }
131              
132             inline _GLIBCXX_CONSTEXPR _Ios_Openmode
133             operator^(_Ios_Openmode __a, _Ios_Openmode __b)
134             { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); }
135              
136             inline _GLIBCXX_CONSTEXPR _Ios_Openmode
137             operator~(_Ios_Openmode __a)
138             { return _Ios_Openmode(~static_cast(__a)); }
139              
140             inline const _Ios_Openmode&
141             operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
142             { return __a = __a | __b; }
143              
144             inline const _Ios_Openmode&
145             operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
146             { return __a = __a & __b; }
147              
148             inline const _Ios_Openmode&
149             operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
150             { return __a = __a ^ __b; }
151              
152              
153             enum _Ios_Iostate
154             {
155             _S_goodbit = 0,
156             _S_badbit = 1L << 0,
157             _S_eofbit = 1L << 1,
158             _S_failbit = 1L << 2,
159             _S_ios_iostate_end = 1L << 16,
160             _S_ios_iostate_max = __INT_MAX__,
161             _S_ios_iostate_min = ~__INT_MAX__
162             };
163              
164             inline _GLIBCXX_CONSTEXPR _Ios_Iostate
165             operator&(_Ios_Iostate __a, _Ios_Iostate __b)
166             { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); }
167              
168             inline _GLIBCXX_CONSTEXPR _Ios_Iostate
169             operator|(_Ios_Iostate __a, _Ios_Iostate __b)
170             { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); }
171              
172             inline _GLIBCXX_CONSTEXPR _Ios_Iostate
173             operator^(_Ios_Iostate __a, _Ios_Iostate __b)
174             { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); }
175              
176             inline _GLIBCXX_CONSTEXPR _Ios_Iostate
177             operator~(_Ios_Iostate __a)
178             { return _Ios_Iostate(~static_cast(__a)); }
179              
180             inline const _Ios_Iostate&
181             operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
182             { return __a = __a | __b; }
183              
184             inline const _Ios_Iostate&
185             operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
186             { return __a = __a & __b; }
187              
188             inline const _Ios_Iostate&
189             operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
190             { return __a = __a ^ __b; }
191              
192              
193             enum _Ios_Seekdir
194             {
195             _S_beg = 0,
196             _S_cur = _GLIBCXX_STDIO_SEEK_CUR,
197             _S_end = _GLIBCXX_STDIO_SEEK_END,
198             _S_ios_seekdir_end = 1L << 16
199             };
200              
201             #if __cplusplus >= 201103L
202             /// I/O error code
203             enum class io_errc { stream = 1 };
204              
205             template <> struct is_error_code_enum : public true_type { };
206              
207             const error_category& iostream_category() noexcept;
208              
209             inline error_code
210             make_error_code(io_errc e) noexcept
211             { return error_code(static_cast(e), iostream_category()); }
212              
213             inline error_condition
214             make_error_condition(io_errc e) noexcept
215             { return error_condition(static_cast(e), iostream_category()); }
216             #endif
217              
218             // 27.4.2 Class ios_base
219             /**
220             * @brief The base of the I/O class hierarchy.
221             * @ingroup io
222             *
223             * This class defines everything that can be defined about I/O that does
224             * not depend on the type of characters being input or output. Most
225             * people will only see @c ios_base when they need to specify the full
226             * name of the various I/O flags (e.g., the openmodes).
227             */
228             class ios_base
229             {
230             #if _GLIBCXX_USE_CXX11_ABI
231             #if __cplusplus < 201103L
232             // Type that is layout-compatible with std::system_error
233             struct system_error : std::runtime_error
234             {
235             // Type that is layout-compatible with std::error_code
236             struct error_code
237             {
238             error_code() { }
239             private:
240             int _M_value;
241             const void* _M_cat;
242             } _M_code;
243             };
244             #endif
245             #endif
246             public:
247              
248             /**
249             * @brief These are thrown to indicate problems with io.
250             * @ingroup exceptions
251             *
252             * 27.4.2.1.1 Class ios_base::failure
253             */
254             #if _GLIBCXX_USE_CXX11_ABI
255             class _GLIBCXX_ABI_TAG_CXX11 failure : public system_error
256             {
257             public:
258             explicit
259             failure(const string& __str);
260              
261             #if __cplusplus >= 201103L
262             explicit
263             failure(const string&, const error_code&);
264              
265             explicit
266             failure(const char*, const error_code& = io_errc::stream);
267             #endif
268              
269             virtual
270             ~failure() throw();
271              
272             virtual const char*
273             what() const throw();
274             };
275             #else
276             class failure : public exception
277             {
278             public:
279             // _GLIBCXX_RESOLVE_LIB_DEFECTS
280             // 48. Use of non-existent exception constructor
281             explicit
282             failure(const string& __str) throw();
283              
284             // This declaration is not useless:
285             // http://gcc.gnu.org/onlinedocs/gcc-4.3.2/gcc/Vague-Linkage.html
286             virtual
287             ~failure() throw();
288              
289             virtual const char*
290             what() const throw();
291              
292             private:
293             string _M_msg;
294             };
295             #endif
296              
297             // 27.4.2.1.2 Type ios_base::fmtflags
298             /**
299             * @brief This is a bitmask type.
300             *
301             * @c @a _Ios_Fmtflags is implementation-defined, but it is valid to
302             * perform bitwise operations on these values and expect the Right
303             * Thing to happen. Defined objects of type fmtflags are:
304             * - boolalpha
305             * - dec
306             * - fixed
307             * - hex
308             * - internal
309             * - left
310             * - oct
311             * - right
312             * - scientific
313             * - showbase
314             * - showpoint
315             * - showpos
316             * - skipws
317             * - unitbuf
318             * - uppercase
319             * - adjustfield
320             * - basefield
321             * - floatfield
322             */
323             typedef _Ios_Fmtflags fmtflags;
324              
325             /// Insert/extract @c bool in alphabetic rather than numeric format.
326             static const fmtflags boolalpha = _S_boolalpha;
327              
328             /// Converts integer input or generates integer output in decimal base.
329             static const fmtflags dec = _S_dec;
330              
331             /// Generate floating-point output in fixed-point notation.
332             static const fmtflags fixed = _S_fixed;
333              
334             /// Converts integer input or generates integer output in hexadecimal base.
335             static const fmtflags hex = _S_hex;
336              
337             /// Adds fill characters at a designated internal point in certain
338             /// generated output, or identical to @c right if no such point is
339             /// designated.
340             static const fmtflags internal = _S_internal;
341              
342             /// Adds fill characters on the right (final positions) of certain
343             /// generated output. (I.e., the thing you print is flush left.)
344             static const fmtflags left = _S_left;
345              
346             /// Converts integer input or generates integer output in octal base.
347             static const fmtflags oct = _S_oct;
348              
349             /// Adds fill characters on the left (initial positions) of certain
350             /// generated output. (I.e., the thing you print is flush right.)
351             static const fmtflags right = _S_right;
352              
353             /// Generates floating-point output in scientific notation.
354             static const fmtflags scientific = _S_scientific;
355              
356             /// Generates a prefix indicating the numeric base of generated integer
357             /// output.
358             static const fmtflags showbase = _S_showbase;
359              
360             /// Generates a decimal-point character unconditionally in generated
361             /// floating-point output.
362             static const fmtflags showpoint = _S_showpoint;
363              
364             /// Generates a + sign in non-negative generated numeric output.
365             static const fmtflags showpos = _S_showpos;
366              
367             /// Skips leading white space before certain input operations.
368             static const fmtflags skipws = _S_skipws;
369              
370             /// Flushes output after each output operation.
371             static const fmtflags unitbuf = _S_unitbuf;
372              
373             /// Replaces certain lowercase letters with their uppercase equivalents
374             /// in generated output.
375             static const fmtflags uppercase = _S_uppercase;
376              
377             /// A mask of left|right|internal. Useful for the 2-arg form of @c setf.
378             static const fmtflags adjustfield = _S_adjustfield;
379              
380             /// A mask of dec|oct|hex. Useful for the 2-arg form of @c setf.
381             static const fmtflags basefield = _S_basefield;
382              
383             /// A mask of scientific|fixed. Useful for the 2-arg form of @c setf.
384             static const fmtflags floatfield = _S_floatfield;
385              
386             // 27.4.2.1.3 Type ios_base::iostate
387             /**
388             * @brief This is a bitmask type.
389             *
390             * @c @a _Ios_Iostate is implementation-defined, but it is valid to
391             * perform bitwise operations on these values and expect the Right
392             * Thing to happen. Defined objects of type iostate are:
393             * - badbit
394             * - eofbit
395             * - failbit
396             * - goodbit
397             */
398             typedef _Ios_Iostate iostate;
399              
400             /// Indicates a loss of integrity in an input or output sequence (such
401             /// as an irrecoverable read error from a file).
402             static const iostate badbit = _S_badbit;
403              
404             /// Indicates that an input operation reached the end of an input sequence.
405             static const iostate eofbit = _S_eofbit;
406              
407             /// Indicates that an input operation failed to read the expected
408             /// characters, or that an output operation failed to generate the
409             /// desired characters.
410             static const iostate failbit = _S_failbit;
411              
412             /// Indicates all is well.
413             static const iostate goodbit = _S_goodbit;
414              
415             // 27.4.2.1.4 Type ios_base::openmode
416             /**
417             * @brief This is a bitmask type.
418             *
419             * @c @a _Ios_Openmode is implementation-defined, but it is valid to
420             * perform bitwise operations on these values and expect the Right
421             * Thing to happen. Defined objects of type openmode are:
422             * - app
423             * - ate
424             * - binary
425             * - in
426             * - out
427             * - trunc
428             */
429             typedef _Ios_Openmode openmode;
430              
431             /// Seek to end before each write.
432             static const openmode app = _S_app;
433              
434             /// Open and seek to end immediately after opening.
435             static const openmode ate = _S_ate;
436              
437             /// Perform input and output in binary mode (as opposed to text mode).
438             /// This is probably not what you think it is; see
439             /// https://gcc.gnu.org/onlinedocs/libstdc++/manual/fstreams.html#std.io.filestreams.binary
440             static const openmode binary = _S_bin;
441              
442             /// Open for input. Default for @c ifstream and fstream.
443             static const openmode in = _S_in;
444              
445             /// Open for output. Default for @c ofstream and fstream.
446             static const openmode out = _S_out;
447              
448             /// Open for input. Default for @c ofstream.
449             static const openmode trunc = _S_trunc;
450              
451             // 27.4.2.1.5 Type ios_base::seekdir
452             /**
453             * @brief This is an enumerated type.
454             *
455             * @c @a _Ios_Seekdir is implementation-defined. Defined values
456             * of type seekdir are:
457             * - beg
458             * - cur, equivalent to @c SEEK_CUR in the C standard library.
459             * - end, equivalent to @c SEEK_END in the C standard library.
460             */
461             typedef _Ios_Seekdir seekdir;
462              
463             /// Request a seek relative to the beginning of the stream.
464             static const seekdir beg = _S_beg;
465              
466             /// Request a seek relative to the current position within the sequence.
467             static const seekdir cur = _S_cur;
468              
469             /// Request a seek relative to the current end of the sequence.
470             static const seekdir end = _S_end;
471              
472             // Annex D.6
473             typedef int io_state;
474             typedef int open_mode;
475             typedef int seek_dir;
476              
477             typedef std::streampos streampos;
478             typedef std::streamoff streamoff;
479              
480             // Callbacks;
481             /**
482             * @brief The set of events that may be passed to an event callback.
483             *
484             * erase_event is used during ~ios() and copyfmt(). imbue_event is used
485             * during imbue(). copyfmt_event is used during copyfmt().
486             */
487             enum event
488             {
489             erase_event,
490             imbue_event,
491             copyfmt_event
492             };
493              
494             /**
495             * @brief The type of an event callback function.
496             * @param __e One of the members of the event enum.
497             * @param __b Reference to the ios_base object.
498             * @param __i The integer provided when the callback was registered.
499             *
500             * Event callbacks are user defined functions that get called during
501             * several ios_base and basic_ios functions, specifically imbue(),
502             * copyfmt(), and ~ios().
503             */
504             typedef void (*event_callback) (event __e, ios_base& __b, int __i);
505              
506             /**
507             * @brief Add the callback __fn with parameter __index.
508             * @param __fn The function to add.
509             * @param __index The integer to pass to the function when invoked.
510             *
511             * Registers a function as an event callback with an integer parameter to
512             * be passed to the function when invoked. Multiple copies of the
513             * function are allowed. If there are multiple callbacks, they are
514             * invoked in the order they were registered.
515             */
516             void
517             register_callback(event_callback __fn, int __index);
518              
519             protected:
520             streamsize _M_precision;
521             streamsize _M_width;
522             fmtflags _M_flags;
523             iostate _M_exception;
524             iostate _M_streambuf_state;
525              
526             // 27.4.2.6 Members for callbacks
527             // 27.4.2.6 ios_base callbacks
528             struct _Callback_list
529             {
530             // Data Members
531             _Callback_list* _M_next;
532             ios_base::event_callback _M_fn;
533             int _M_index;
534             _Atomic_word _M_refcount; // 0 means one reference.
535              
536             _Callback_list(ios_base::event_callback __fn, int __index,
537             _Callback_list* __cb)
538             : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
539              
540             void
541             _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
542              
543             // 0 => OK to delete.
544             int
545             _M_remove_reference()
546             {
547             // Be race-detector-friendly. For more info see bits/c++config.
548             _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_refcount);
549             int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
550             if (__res == 0)
551             {
552             _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_refcount);
553             }
554             return __res;
555             }
556             };
557              
558             _Callback_list* _M_callbacks;
559              
560             void
561             _M_call_callbacks(event __ev) throw();
562              
563             void
564             _M_dispose_callbacks(void) throw();
565              
566             // 27.4.2.5 Members for iword/pword storage
567             struct _Words
568             {
569             void* _M_pword;
570             long _M_iword;
571             _Words() : _M_pword(0), _M_iword(0) { }
572             };
573              
574             // Only for failed iword/pword calls.
575             _Words _M_word_zero;
576              
577             // Guaranteed storage.
578             // The first 5 iword and pword slots are reserved for internal use.
579             enum { _S_local_word_size = 8 };
580             _Words _M_local_word[_S_local_word_size];
581              
582             // Allocated storage.
583             int _M_word_size;
584             _Words* _M_word;
585              
586             _Words&
587             _M_grow_words(int __index, bool __iword);
588              
589             // Members for locale and locale caching.
590             locale _M_ios_locale;
591              
592             void
593             _M_init() throw();
594              
595             public:
596              
597             // 27.4.2.1.6 Class ios_base::Init
598             // Used to initialize standard streams. In theory, g++ could use
599             // -finit-priority to order this stuff correctly without going
600             // through these machinations.
601             class Init
602             {
603             friend class ios_base;
604             public:
605             Init();
606             ~Init();
607              
608             private:
609             static _Atomic_word _S_refcount;
610             static bool _S_synced_with_stdio;
611             };
612              
613             // [27.4.2.2] fmtflags state functions
614             /**
615             * @brief Access to format flags.
616             * @return The format control flags for both input and output.
617             */
618             fmtflags
619             flags() const
620             { return _M_flags; }
621              
622             /**
623             * @brief Setting new format flags all at once.
624             * @param __fmtfl The new flags to set.
625             * @return The previous format control flags.
626             *
627             * This function overwrites all the format flags with @a __fmtfl.
628             */
629             fmtflags
630             flags(fmtflags __fmtfl)
631             {
632             fmtflags __old = _M_flags;
633             _M_flags = __fmtfl;
634             return __old;
635             }
636              
637             /**
638             * @brief Setting new format flags.
639             * @param __fmtfl Additional flags to set.
640             * @return The previous format control flags.
641             *
642             * This function sets additional flags in format control. Flags that
643             * were previously set remain set.
644             */
645             fmtflags
646             setf(fmtflags __fmtfl)
647             {
648             fmtflags __old = _M_flags;
649             _M_flags |= __fmtfl;
650             return __old;
651             }
652              
653             /**
654             * @brief Setting new format flags.
655             * @param __fmtfl Additional flags to set.
656             * @param __mask The flags mask for @a fmtfl.
657             * @return The previous format control flags.
658             *
659             * This function clears @a mask in the format flags, then sets
660             * @a fmtfl @c & @a mask. An example mask is @c ios_base::adjustfield.
661             */
662             fmtflags
663             setf(fmtflags __fmtfl, fmtflags __mask)
664             {
665             fmtflags __old = _M_flags;
666             _M_flags &= ~__mask;
667             _M_flags |= (__fmtfl & __mask);
668             return __old;
669             }
670              
671             /**
672             * @brief Clearing format flags.
673             * @param __mask The flags to unset.
674             *
675             * This function clears @a __mask in the format flags.
676             */
677             void
678             unsetf(fmtflags __mask)
679             { _M_flags &= ~__mask; }
680              
681             /**
682             * @brief Flags access.
683             * @return The precision to generate on certain output operations.
684             *
685             * Be careful if you try to give a definition of @a precision here; see
686             * DR 189.
687             */
688             streamsize
689             precision() const
690             { return _M_precision; }
691              
692             /**
693             * @brief Changing flags.
694             * @param __prec The new precision value.
695             * @return The previous value of precision().
696             */
697             streamsize
698             precision(streamsize __prec)
699             {
700             streamsize __old = _M_precision;
701             _M_precision = __prec;
702             return __old;
703             }
704              
705             /**
706             * @brief Flags access.
707             * @return The minimum field width to generate on output operations.
708             *
709             * Minimum field width refers to the number of characters.
710             */
711             streamsize
712             width() const
713             { return _M_width; }
714              
715             /**
716             * @brief Changing flags.
717             * @param __wide The new width value.
718             * @return The previous value of width().
719             */
720             streamsize
721             width(streamsize __wide)
722             {
723             streamsize __old = _M_width;
724             _M_width = __wide;
725             return __old;
726             }
727              
728             // [27.4.2.4] ios_base static members
729             /**
730             * @brief Interaction with the standard C I/O objects.
731             * @param __sync Whether to synchronize or not.
732             * @return True if the standard streams were previously synchronized.
733             *
734             * The synchronization referred to is @e only that between the standard
735             * C facilities (e.g., stdout) and the standard C++ objects (e.g.,
736             * cout). User-declared streams are unaffected. See
737             * https://gcc.gnu.org/onlinedocs/libstdc++/manual/fstreams.html#std.io.filestreams.binary
738             */
739             static bool
740             sync_with_stdio(bool __sync = true);
741              
742             // [27.4.2.3] ios_base locale functions
743             /**
744             * @brief Setting a new locale.
745             * @param __loc The new locale.
746             * @return The previous locale.
747             *
748             * Sets the new locale for this stream, and then invokes each callback
749             * with imbue_event.
750             */
751             locale
752             imbue(const locale& __loc) throw();
753              
754             /**
755             * @brief Locale access
756             * @return A copy of the current locale.
757             *
758             * If @c imbue(loc) has previously been called, then this function
759             * returns @c loc. Otherwise, it returns a copy of @c std::locale(),
760             * the global C++ locale.
761             */
762             locale
763             getloc() const
764             { return _M_ios_locale; }
765              
766             /**
767             * @brief Locale access
768             * @return A reference to the current locale.
769             *
770             * Like getloc above, but returns a reference instead of
771             * generating a copy.
772             */
773             const locale&
774             _M_getloc() const
775             { return _M_ios_locale; }
776              
777             // [27.4.2.5] ios_base storage functions
778             /**
779             * @brief Access to unique indices.
780             * @return An integer different from all previous calls.
781             *
782             * This function returns a unique integer every time it is called. It
783             * can be used for any purpose, but is primarily intended to be a unique
784             * index for the iword and pword functions. The expectation is that an
785             * application calls xalloc in order to obtain an index in the iword and
786             * pword arrays that can be used without fear of conflict.
787             *
788             * The implementation maintains a static variable that is incremented and
789             * returned on each invocation. xalloc is guaranteed to return an index
790             * that is safe to use in the iword and pword arrays.
791             */
792             static int
793             xalloc() throw();
794              
795             /**
796             * @brief Access to integer array.
797             * @param __ix Index into the array.
798             * @return A reference to an integer associated with the index.
799             *
800             * The iword function provides access to an array of integers that can be
801             * used for any purpose. The array grows as required to hold the
802             * supplied index. All integers in the array are initialized to 0.
803             *
804             * The implementation reserves several indices. You should use xalloc to
805             * obtain an index that is safe to use. Also note that since the array
806             * can grow dynamically, it is not safe to hold onto the reference.
807             */
808             long&
809             iword(int __ix)
810             {
811             _Words& __word = (__ix < _M_word_size)
812             ? _M_word[__ix] : _M_grow_words(__ix, true);
813             return __word._M_iword;
814             }
815              
816             /**
817             * @brief Access to void pointer array.
818             * @param __ix Index into the array.
819             * @return A reference to a void* associated with the index.
820             *
821             * The pword function provides access to an array of pointers that can be
822             * used for any purpose. The array grows as required to hold the
823             * supplied index. All pointers in the array are initialized to 0.
824             *
825             * The implementation reserves several indices. You should use xalloc to
826             * obtain an index that is safe to use. Also note that since the array
827             * can grow dynamically, it is not safe to hold onto the reference.
828             */
829             void*&
830             pword(int __ix)
831             {
832             _Words& __word = (__ix < _M_word_size)
833             ? _M_word[__ix] : _M_grow_words(__ix, false);
834             return __word._M_pword;
835             }
836              
837             // Destructor
838             /**
839             * Invokes each callback with erase_event. Destroys local storage.
840             *
841             * Note that the ios_base object for the standard streams never gets
842             * destroyed. As a result, any callbacks registered with the standard
843             * streams will not get invoked with erase_event (unless copyfmt is
844             * used).
845             */
846             virtual ~ios_base();
847              
848             protected:
849             ios_base() throw ();
850              
851             #if __cplusplus < 201103L
852             // _GLIBCXX_RESOLVE_LIB_DEFECTS
853             // 50. Copy constructor and assignment operator of ios_base
854             private:
855             ios_base(const ios_base&);
856              
857             ios_base&
858             operator=(const ios_base&);
859             #else
860             public:
861             ios_base(const ios_base&) = delete;
862              
863             ios_base&
864             operator=(const ios_base&) = delete;
865              
866             protected:
867             void
868             _M_move(ios_base&) noexcept;
869              
870             void
871             _M_swap(ios_base& __rhs) noexcept;
872             #endif
873             };
874              
875             // [27.4.5.1] fmtflags manipulators
876             /// Calls base.setf(ios_base::boolalpha).
877             inline ios_base&
878             boolalpha(ios_base& __base)
879             {
880             __base.setf(ios_base::boolalpha);
881             return __base;
882             }
883              
884             /// Calls base.unsetf(ios_base::boolalpha).
885             inline ios_base&
886             noboolalpha(ios_base& __base)
887             {
888             __base.unsetf(ios_base::boolalpha);
889             return __base;
890             }
891              
892             /// Calls base.setf(ios_base::showbase).
893             inline ios_base&
894             showbase(ios_base& __base)
895             {
896             __base.setf(ios_base::showbase);
897             return __base;
898             }
899              
900             /// Calls base.unsetf(ios_base::showbase).
901             inline ios_base&
902             noshowbase(ios_base& __base)
903             {
904             __base.unsetf(ios_base::showbase);
905             return __base;
906             }
907              
908             /// Calls base.setf(ios_base::showpoint).
909             inline ios_base&
910             showpoint(ios_base& __base)
911             {
912             __base.setf(ios_base::showpoint);
913             return __base;
914             }
915              
916             /// Calls base.unsetf(ios_base::showpoint).
917             inline ios_base&
918             noshowpoint(ios_base& __base)
919             {
920             __base.unsetf(ios_base::showpoint);
921             return __base;
922             }
923              
924             /// Calls base.setf(ios_base::showpos).
925             inline ios_base&
926             showpos(ios_base& __base)
927             {
928             __base.setf(ios_base::showpos);
929             return __base;
930             }
931              
932             /// Calls base.unsetf(ios_base::showpos).
933             inline ios_base&
934             noshowpos(ios_base& __base)
935             {
936             __base.unsetf(ios_base::showpos);
937             return __base;
938             }
939              
940             /// Calls base.setf(ios_base::skipws).
941             inline ios_base&
942             skipws(ios_base& __base)
943             {
944             __base.setf(ios_base::skipws);
945             return __base;
946             }
947              
948             /// Calls base.unsetf(ios_base::skipws).
949             inline ios_base&
950             noskipws(ios_base& __base)
951             {
952             __base.unsetf(ios_base::skipws);
953             return __base;
954             }
955              
956             /// Calls base.setf(ios_base::uppercase).
957             inline ios_base&
958             uppercase(ios_base& __base)
959             {
960             __base.setf(ios_base::uppercase);
961             return __base;
962             }
963              
964             /// Calls base.unsetf(ios_base::uppercase).
965             inline ios_base&
966             nouppercase(ios_base& __base)
967             {
968             __base.unsetf(ios_base::uppercase);
969             return __base;
970             }
971              
972             /// Calls base.setf(ios_base::unitbuf).
973             inline ios_base&
974             unitbuf(ios_base& __base)
975             {
976             __base.setf(ios_base::unitbuf);
977             return __base;
978             }
979              
980             /// Calls base.unsetf(ios_base::unitbuf).
981             inline ios_base&
982             nounitbuf(ios_base& __base)
983             {
984             __base.unsetf(ios_base::unitbuf);
985             return __base;
986             }
987              
988             // [27.4.5.2] adjustfield manipulators
989             /// Calls base.setf(ios_base::internal, ios_base::adjustfield).
990             inline ios_base&
991             internal(ios_base& __base)
992             {
993             __base.setf(ios_base::internal, ios_base::adjustfield);
994             return __base;
995             }
996              
997             /// Calls base.setf(ios_base::left, ios_base::adjustfield).
998             inline ios_base&
999             left(ios_base& __base)
1000             {
1001             __base.setf(ios_base::left, ios_base::adjustfield);
1002             return __base;
1003             }
1004              
1005             /// Calls base.setf(ios_base::right, ios_base::adjustfield).
1006             inline ios_base&
1007             right(ios_base& __base)
1008             {
1009             __base.setf(ios_base::right, ios_base::adjustfield);
1010             return __base;
1011             }
1012              
1013             // [27.4.5.3] basefield manipulators
1014             /// Calls base.setf(ios_base::dec, ios_base::basefield).
1015             inline ios_base&
1016             dec(ios_base& __base)
1017             {
1018             __base.setf(ios_base::dec, ios_base::basefield);
1019             return __base;
1020             }
1021              
1022             /// Calls base.setf(ios_base::hex, ios_base::basefield).
1023             inline ios_base&
1024             hex(ios_base& __base)
1025             {
1026             __base.setf(ios_base::hex, ios_base::basefield);
1027             return __base;
1028             }
1029              
1030             /// Calls base.setf(ios_base::oct, ios_base::basefield).
1031             inline ios_base&
1032             oct(ios_base& __base)
1033             {
1034             __base.setf(ios_base::oct, ios_base::basefield);
1035             return __base;
1036             }
1037              
1038             // [27.4.5.4] floatfield manipulators
1039             /// Calls base.setf(ios_base::fixed, ios_base::floatfield).
1040             inline ios_base&
1041             fixed(ios_base& __base)
1042             {
1043             __base.setf(ios_base::fixed, ios_base::floatfield);
1044             return __base;
1045             }
1046              
1047             /// Calls base.setf(ios_base::scientific, ios_base::floatfield).
1048             inline ios_base&
1049             scientific(ios_base& __base)
1050             {
1051             __base.setf(ios_base::scientific, ios_base::floatfield);
1052             return __base;
1053             }
1054              
1055             #if __cplusplus >= 201103L
1056             // New C++11 floatfield manipulators
1057              
1058             /// Calls
1059             /// base.setf(ios_base::fixed|ios_base::scientific, ios_base::floatfield)
1060             inline ios_base&
1061             hexfloat(ios_base& __base)
1062             {
1063             __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
1064             return __base;
1065             }
1066              
1067             /// Calls @c base.unsetf(ios_base::floatfield)
1068             inline ios_base&
1069             defaultfloat(ios_base& __base)
1070             {
1071             __base.unsetf(ios_base::floatfield);
1072             return __base;
1073             }
1074             #endif
1075              
1076             _GLIBCXX_END_NAMESPACE_VERSION
1077             } // namespace
1078              
1079             #endif /* _IOS_BASE_H */