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