libstdc++-v3/include/bits/ios_base.h

   1 // Iostreams base classes -*- C++ -*-
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001 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 2, 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 // You should have received a copy of the GNU General Public License along
  17 // with this library; see the file COPYING.  If not, write to the Free
  18 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19 // USA.
  20
  21 // As a special exception, you may use this file as part of a free software
  22 // library without restriction.  Specifically, if other files instantiate
  23 // templates or use macros or inline functions from this file, or you compile
  24 // this file and link it with other files to produce an executable, this
  25 // file does not by itself cause the resulting executable to be covered by
  26 // the GNU General Public License.  This exception does not however
  27 // invalidate any other reasons why the executable file might be covered by
  28 // the GNU General Public License.
  29
  30 //
  31 // ISO C++ 14882: 27.8  File-based streams
  32 //
  33
  34 #ifndef _CPP_BITS_IOSBASE_H
  35 #define _CPP_BITS_IOSBASE_H 1
  36
  37 #pragma GCC system_header
  38
  39 namespace std {
  40
  41   // The following definitions of bitmask types are enums, not ints,
  42   // as permitted (but not required) in the standard, in order to provide
  43   // better type safety in iostream calls.  A side effect is that
  44   // expressions involving them are no longer compile-time constants.
  45   enum _Ios_Fmtflags { _M_ios_fmtflags_end = 1L << 16 };
  46
  47   inline _Ios_Fmtflags
  48   operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  49   { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
  50
  51   inline _Ios_Fmtflags
  52   operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  53   { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
  54
  55   inline _Ios_Fmtflags
  56   operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  57   { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
  58
  59   inline _Ios_Fmtflags
  60   operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  61   { return __a = __a | __b; }
  62
  63   inline _Ios_Fmtflags
  64   operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  65   { return __a = __a & __b; }
  66
  67   inline _Ios_Fmtflags
  68   operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  69   { return __a = __a ^ __b; }
  70
  71   inline _Ios_Fmtflags
  72   operator~(_Ios_Fmtflags __a)
  73   { return _Ios_Fmtflags(~static_cast<int>(__a)); }
  74
  75
  76   enum _Ios_Openmode { _M_ios_openmode_end = 1L << 16 };
  77
  78   inline _Ios_Openmode
  79   operator&(_Ios_Openmode __a, _Ios_Openmode __b)
  80   { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
  81
  82   inline _Ios_Openmode
  83   operator|(_Ios_Openmode __a, _Ios_Openmode __b)
  84   { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
  85
  86   inline _Ios_Openmode
  87   operator^(_Ios_Openmode __a, _Ios_Openmode __b)
  88   { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
  89
  90   inline _Ios_Openmode
  91   operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
  92   { return __a = __a | __b; }
  93
  94   inline _Ios_Openmode
  95   operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
  96   { return __a = __a & __b; }
  97
  98   inline _Ios_Openmode
  99   operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
 100   { return __a = __a ^ __b; }
 101
 102   inline _Ios_Openmode
 103   operator~(_Ios_Openmode __a)
 104   { return _Ios_Openmode(~static_cast<int>(__a)); }
 105
 106
 107   enum _Ios_Iostate { _M_ios_iostate_end = 1L << 16 };
 108
 109   inline _Ios_Iostate
 110   operator&(_Ios_Iostate __a, _Ios_Iostate __b)
 111   { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
 112
 113   inline _Ios_Iostate
 114   operator|(_Ios_Iostate __a, _Ios_Iostate __b)
 115   { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
 116
 117   inline _Ios_Iostate
 118   operator^(_Ios_Iostate __a, _Ios_Iostate __b)
 119   { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
 120
 121   inline _Ios_Iostate
 122   operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
 123   { return __a = __a | __b; }
 124
 125   inline _Ios_Iostate
 126   operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
 127   { return __a = __a & __b; }
 128
 129   inline _Ios_Iostate
 130   operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
 131   { return __a = __a ^ __b; }
 132
 133   inline _Ios_Iostate
 134   operator~(_Ios_Iostate __a)
 135   { return _Ios_Iostate(~static_cast<int>(__a)); }
 136
 137   enum _Ios_Seekdir { _M_ios_seekdir_end = 1L << 16 };
 138
 139   // 27.4.2  Class ios_base
 140   class ios_base
 141   {
 142   public:
 143
 144     // 27.4.2.1.1  Class ios_base::failure
 145     class failure : public exception
 146     {
 147     public:
 148 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 149       // Can't do exception(_msg) as defined in 27.4.2.1.1
 150       explicit
 151       failure(const string& __str) throw();
 152
 153       virtual
 154       ~failure() throw();
 155
 156       virtual const char*
 157       what() const throw();
 158
 159     private:
 160       enum { _M_bufsize = 256 };
 161       char _M_name[_M_bufsize];
 162 #endif
 163     };
 164
 165     // 27.4.2.1.2  Type ios_base::fmtflags
 166     typedef _Ios_Fmtflags fmtflags;
 167     // 27.4.2.1.2  Type fmtflags
 168     static const fmtflags boolalpha =   fmtflags(__ios_flags::_S_boolalpha);
 169     static const fmtflags dec =         fmtflags(__ios_flags::_S_dec);
 170     static const fmtflags fixed =       fmtflags(__ios_flags::_S_fixed);
 171     static const fmtflags hex =         fmtflags(__ios_flags::_S_hex);
 172     static const fmtflags internal =    fmtflags(__ios_flags::_S_internal);
 173     static const fmtflags left =        fmtflags(__ios_flags::_S_left);
 174     static const fmtflags oct =         fmtflags(__ios_flags::_S_oct);
 175     static const fmtflags right =       fmtflags(__ios_flags::_S_right);
 176     static const fmtflags scientific =  fmtflags(__ios_flags::_S_scientific);
 177     static const fmtflags showbase =    fmtflags(__ios_flags::_S_showbase);
 178     static const fmtflags showpoint =   fmtflags(__ios_flags::_S_showpoint);
 179     static const fmtflags showpos =     fmtflags(__ios_flags::_S_showpos);
 180     static const fmtflags skipws =      fmtflags(__ios_flags::_S_skipws);
 181     static const fmtflags unitbuf =     fmtflags(__ios_flags::_S_unitbuf);
 182     static const fmtflags uppercase =   fmtflags(__ios_flags::_S_uppercase);
 183     static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);
 184     static const fmtflags basefield =   fmtflags(__ios_flags::_S_basefield);
 185     static const fmtflags floatfield =  fmtflags(__ios_flags::_S_floatfield);
 186
 187     // 27.4.2.1.3  Type ios_base::iostate
 188     typedef _Ios_Iostate iostate;
 189     static const iostate badbit =       iostate(__ios_flags::_S_badbit);
 190     static const iostate eofbit =       iostate(__ios_flags::_S_eofbit);
 191     static const iostate failbit =      iostate(__ios_flags::_S_failbit);
 192     static const iostate goodbit =      iostate(0);
 193
 194     // 27.4.2.1.4  Type openmode
 195     typedef _Ios_Openmode openmode;
 196     static const openmode app =         openmode(__ios_flags::_S_app);
 197     static const openmode ate =         openmode(__ios_flags::_S_ate);
 198     static const openmode binary =      openmode(__ios_flags::_S_bin);
 199     static const openmode in =          openmode(__ios_flags::_S_in);
 200     static const openmode out =         openmode(__ios_flags::_S_out);
 201     static const openmode trunc =       openmode(__ios_flags::_S_trunc);
 202
 203     // 27.4.2.1.5  Type seekdir
 204     typedef _Ios_Seekdir seekdir;
 205     static const seekdir beg =          seekdir(0);
 206     static const seekdir cur =          seekdir(SEEK_CUR);
 207     static const seekdir end =          seekdir(SEEK_END);
 208
 209 #ifdef _GLIBCPP_DEPRECATED
 210     typedef int io_state;
 211     typedef int open_mode;
 212     typedef int seek_dir;
 213 #endif
 214
 215     // Callbacks;
 216     enum event
 217     {
 218       erase_event,
 219       imbue_event,
 220       copyfmt_event
 221     };
 222
 223     typedef void (*event_callback) (event, ios_base&, int);
 224
 225     void
 226     register_callback(event_callback __fn, int __index);
 227
 228   protected:
 229     // Data Members
 230     streamsize          _M_precision;
 231     streamsize          _M_width;
 232     fmtflags            _M_flags;
 233
 234     // 27.4.2.6  Members for callbacks
 235     // 27.4.2.6  ios_base callbacks
 236     struct _Callback_list
 237     {
 238       // Data Members
 239       _Callback_list*           _M_next;
 240       ios_base::event_callback  _M_fn;
 241       int                       _M_index;
 242       int                       _M_refcount;  // 0 means one reference.
 243
 244       _Callback_list(ios_base::event_callback __fn, int __index,
 245                      _Callback_list* __cb)
 246       : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
 247
 248       void
 249       _M_add_reference() { ++_M_refcount; } // XXX MT
 250
 251       int
 252       _M_remove_reference() { return _M_refcount--; }  // 0 => OK to delete
 253     };
 254
 255      _Callback_list*    _M_callbacks;
 256
 257     void
 258     _M_call_callbacks(event __ev) throw();
 259
 260     void
 261     _M_dispose_callbacks(void);
 262
 263     // 27.4.2.5  Members for iword/pword storage
 264     struct _Words
 265     {
 266       void*     _M_pword;
 267       long      _M_iword;
 268     };
 269
 270     static const int    _S_local_words = 8;
 271     _Words              _M_word_array[_S_local_words];  // Guaranteed storage
 272     _Words              _M_dummy;    // Only for failed iword/pword calls.
 273     _Words*             _M_words;
 274     int                 _M_word_limit;
 275
 276     _Words&
 277     _M_grow_words(int __index);
 278
 279     // Members for locale and locale caching.
 280     locale              _M_ios_locale;
 281
 282     void
 283     _M_init();
 284
 285   public:
 286
 287     // 27.4.2.1.6  Class ios_base::Init
 288     // Used to initialize standard streams. In theory, g++ could use
 289     // -finit-priority to order this stuff correctly without going
 290     // through these machinations.
 291     class Init
 292     {
 293       friend class ios_base;
 294     public:
 295       Init();
 296       ~Init();
 297     private:
 298       static int        _S_ios_base_init;
 299       static bool       _S_synced_with_stdio;
 300       filebuf*          _M_cout;
 301       filebuf*          _M_cin;
 302       filebuf*          _M_cerr;
 303 #ifdef _GLIBCPP_USE_WCHAR_T
 304       wfilebuf*         _M_wcout;
 305       wfilebuf*         _M_wcin;
 306       wfilebuf*         _M_wcerr;
 307 #endif
 308     };
 309
 310     // Fmtflags state:
 311     inline fmtflags
 312     flags() const { return _M_flags; }
 313
 314     inline fmtflags
 315     flags(fmtflags __fmtfl)
 316     {
 317       fmtflags __old = _M_flags;
 318       _M_flags = __fmtfl;
 319       return __old;
 320     }
 321
 322     inline fmtflags
 323     setf(fmtflags __fmtfl)
 324     {
 325       fmtflags __old = _M_flags;
 326       _M_flags |= __fmtfl;
 327       return __old;
 328     }
 329
 330     inline fmtflags
 331     setf(fmtflags __fmtfl, fmtflags __mask)
 332     {
 333       fmtflags __old = _M_flags;
 334       _M_flags &= ~__mask;
 335       _M_flags |= (__fmtfl & __mask);
 336       return __old;
 337     }
 338
 339     inline void
 340     unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
 341
 342     inline streamsize
 343     precision() const { return _M_precision; }
 344
 345     inline streamsize
 346     precision(streamsize __prec)
 347     {
 348       streamsize __old = _M_precision;
 349       _M_precision = __prec;
 350       return __old;
 351     }
 352
 353     inline streamsize
 354     width() const { return _M_width; }
 355
 356     inline streamsize
 357     width(streamsize __wide)
 358     {
 359       streamsize __old = _M_width;
 360       _M_width = __wide;
 361       return __old;
 362     }
 363
 364     static bool
 365     sync_with_stdio(bool __sync = true);
 366
 367     // Locales:
 368     locale
 369     imbue(const locale& __loc);
 370
 371     inline locale
 372     getloc() const { return _M_ios_locale; }
 373
 374     // Storage:
 375     static int
 376     xalloc() throw();
 377
 378     inline long&
 379     iword(int __ix)
 380     {
 381       _Words& __word = (__ix < _M_word_limit)
 382                         ? _M_words[__ix] : _M_grow_words(__ix);
 383       return __word._M_iword;
 384     }
 385
 386     inline void*&
 387     pword(int __ix)
 388     {
 389       _Words& __word = (__ix < _M_word_limit)
 390                         ? _M_words[__ix] : _M_grow_words(__ix);
 391       return __word._M_pword;
 392     }
 393
 394     // Destructor
 395     ~ios_base();
 396
 397   protected:
 398     ios_base();
 399
 400 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 401   private:
 402     ios_base(const ios_base&);
 403
 404     ios_base&
 405     operator=(const ios_base&);
 406 #endif
 407   };
 408
 409   // 27.4.5.1 fmtflags manipulators:
 410   inline ios_base&
 411   boolalpha(ios_base& __base)
 412   {
 413     __base.setf(ios_base::boolalpha);
 414     return __base;
 415   }
 416
 417   inline ios_base&
 418   noboolalpha(ios_base& __base)
 419   {
 420     __base.unsetf(ios_base::boolalpha);
 421     return __base;
 422   }
 423
 424   inline ios_base&
 425   showbase(ios_base& __base)
 426   {
 427     __base.setf(ios_base::showbase);
 428     return __base;
 429   }
 430
 431   inline ios_base&
 432   noshowbase(ios_base& __base)
 433   {
 434     __base.unsetf(ios_base::showbase);
 435     return __base;
 436   }
 437
 438   inline ios_base&
 439   showpoint(ios_base& __base)
 440   {
 441     __base.setf(ios_base::showpoint);
 442     return __base;
 443   }
 444
 445   inline ios_base&
 446   noshowpoint(ios_base& __base)
 447   {
 448     __base.unsetf(ios_base::showpoint);
 449     return __base;
 450   }
 451
 452   inline ios_base&
 453   showpos(ios_base& __base)
 454   {
 455     __base.setf(ios_base::showpos);
 456     return __base;
 457   }
 458
 459   inline ios_base&
 460   noshowpos(ios_base& __base)
 461   {
 462     __base.unsetf(ios_base::showpos);
 463     return __base;
 464   }
 465
 466   inline ios_base&
 467   skipws(ios_base& __base)
 468   {
 469     __base.setf(ios_base::skipws);
 470     return __base;
 471   }
 472
 473   inline ios_base&
 474   noskipws(ios_base& __base)
 475   {
 476     __base.unsetf(ios_base::skipws);
 477     return __base;
 478   }
 479
 480   inline ios_base&
 481   uppercase(ios_base& __base)
 482   {
 483     __base.setf(ios_base::uppercase);
 484     return __base;
 485   }
 486
 487   inline ios_base&
 488   nouppercase(ios_base& __base)
 489   {
 490     __base.unsetf(ios_base::uppercase);
 491     return __base;
 492   }
 493
 494   inline ios_base&
 495   unitbuf(ios_base& __base)
 496   {
 497      __base.setf(ios_base::unitbuf);
 498      return __base;
 499   }
 500
 501   inline ios_base&
 502   nounitbuf(ios_base& __base)
 503   {
 504      __base.unsetf(ios_base::unitbuf);
 505      return __base;
 506   }
 507
 508   // 27.4.5.2 adjustfield anipulators:
 509   inline ios_base&
 510   internal(ios_base& __base)
 511   {
 512      __base.setf(ios_base::internal, ios_base::adjustfield);
 513      return __base;
 514   }
 515
 516   inline ios_base&
 517   left(ios_base& __base)
 518   {
 519     __base.setf(ios_base::left, ios_base::adjustfield);
 520     return __base;
 521   }
 522
 523   inline ios_base&
 524   right(ios_base& __base)
 525   {
 526     __base.setf(ios_base::right, ios_base::adjustfield);
 527     return __base;
 528   }
 529
 530   // 27.4.5.3 basefield anipulators:
 531   inline ios_base&
 532   dec(ios_base& __base)
 533   {
 534     __base.setf(ios_base::dec, ios_base::basefield);
 535     return __base;
 536   }
 537
 538   inline ios_base&
 539   hex(ios_base& __base)
 540   {
 541     __base.setf(ios_base::hex, ios_base::basefield);
 542     return __base;
 543   }
 544
 545   inline ios_base&
 546   oct(ios_base& __base)
 547   {
 548     __base.setf(ios_base::oct, ios_base::basefield);
 549     return __base;
 550   }
 551
 552   // 27.4.5.4 floatfield anipulators:
 553   inline ios_base&
 554   fixed(ios_base& __base)
 555   {
 556     __base.setf(ios_base::fixed, ios_base::floatfield);
 557     return __base;
 558   }
 559
 560   inline ios_base&
 561   scientific(ios_base& __base)
 562   {
 563     __base.setf(ios_base::scientific, ios_base::floatfield);
 564     return __base;
 565   }
 566
 567 } // namespace std
 568
 569 #endif /* _CPP_BITS_IOSBASE_H */
 570
 571
 572
 573
 574
 575
 576
 577
 578