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

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