ios_base.h source code [include/c++/7/bits/ios

1	// Iostreams base classes -- C++ --
2
3	// Copyright (C) 1997-2017 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	// <http://www.gnu.org/licenses/>.
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 <ext/atomicity.h>
40	#include <bits/localefwd.h>
41	#include <bits/locale_classes.h>
42
43	#if __cplusplus < 201103L
44	# include <stdexcept>
45	#else
46	# include <system_error>
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 in C++98
56	// expressions involving them are not 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<int>(__a) & static_cast<int>(__b)); }
85
86	inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
87	operator\|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
88	{ return _Ios_Fmtflags(static_cast<int>(__a) \| static_cast<int>(__b)); }
89
90	inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
91	operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
92	{ return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
93
94	inline _GLIBCXX_CONSTEXPR _Ios_Fmtflags
95	operator~(_Ios_Fmtflags __a)
96	{ return _Ios_Fmtflags(~static_cast<int>(__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<int>(__a) & static_cast<int>(__b)); }
127
128	inline _GLIBCXX_CONSTEXPR _Ios_Openmode
129	operator\|(_Ios_Openmode __a, _Ios_Openmode __b)
130	{ return _Ios_Openmode(static_cast<int>(__a) \| static_cast<int>(__b)); }
131
132	inline _GLIBCXX_CONSTEXPR _Ios_Openmode
133	operator^(_Ios_Openmode __a, _Ios_Openmode __b)
134	{ return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
135
136	inline _GLIBCXX_CONSTEXPR _Ios_Openmode
137	operator~(_Ios_Openmode __a)
138	{ return _Ios_Openmode(~static_cast<int>(__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<int>(__a) & static_cast<int>(__b)); }
167
168	inline _GLIBCXX_CONSTEXPR _Ios_Iostate
169	operator\|(_Ios_Iostate __a, _Ios_Iostate __b)
170	{ return _Ios_Iostate(static_cast<int>(__a) \| static_cast<int>(__b)); }
171
172	inline _GLIBCXX_CONSTEXPR _Ios_Iostate
173	operator^(_Ios_Iostate __a, _Ios_Iostate __b)
174	{ return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
175
176	inline _GLIBCXX_CONSTEXPR _Ios_Iostate
177	operator~(_Ios_Iostate __a)
178	{ return _Ios_Iostate(~static_cast<int>(__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<io_errc> : 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<int>(__e), iostream_category()); }
212
213	inline error_condition
214	make_error_condition(io_errc __e) noexcept
215	{ return error_condition(static_cast<int>(__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	* <em>Minimum field width</em> 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 */
1080