Subversion Repositories Kolibri OS

// Iostreams base classes -*- C++ -*-

// Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the

// terms of the GNU General Public License as published by the

// Free Software Foundation; either version 2, or (at your option)

// any later version.

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along

// with this library; see the file COPYING.  If not, write to the Free

// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,

// USA.

// As a special exception, you may use this file as part of a free software

// library without restriction.  Specifically, if other files instantiate

// templates or use macros or inline functions from this file, or you compile

// this file and link it with other files to produce an executable, this

// file does not by itself cause the resulting executable to be covered by

// the GNU General Public License.  This exception does not however

// invalidate any other reasons why the executable file might be covered by

// the GNU General Public License.

//

// ISO C++ 14882: 27.8  File-based streams

//

#ifndef _CPP_BITS_IOSBASE_H

#define _CPP_BITS_IOSBASE_H 1

#pragma GCC system_header

namespace std

{

  // The following definitions of bitmask types are enums, not ints,

  // as permitted (but not required) in the standard, in order to provide

  // better type safety in iostream calls.  A side effect is that

  // expressions involving them are no longer compile-time constants.

  enum _Ios_Fmtflags { _M_ios_fmtflags_end = 1L << 16 };

  inline _Ios_Fmtflags

  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)

  { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); }

  inline _Ios_Fmtflags

  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)

  { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); }

  inline _Ios_Fmtflags

  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)

  { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); }

  inline _Ios_Fmtflags

  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)

  { return __a = __a | __b; }

  inline _Ios_Fmtflags

  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)

  { return __a = __a & __b; }

  inline _Ios_Fmtflags

  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)

  { return __a = __a ^ __b; }

  inline _Ios_Fmtflags

  operator~(_Ios_Fmtflags __a)

  { return _Ios_Fmtflags(~static_cast(__a)); }

  enum _Ios_Openmode { _M_ios_openmode_end = 1L << 16 };

  inline _Ios_Openmode

  operator&(_Ios_Openmode __a, _Ios_Openmode __b)

  { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); }

  inline _Ios_Openmode

  operator|(_Ios_Openmode __a, _Ios_Openmode __b)

  { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); }

  inline _Ios_Openmode

  operator^(_Ios_Openmode __a, _Ios_Openmode __b)

  { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); }

  inline _Ios_Openmode

  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)

  { return __a = __a | __b; }

  inline _Ios_Openmode

  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)

  { return __a = __a & __b; }

  inline _Ios_Openmode

  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)

  { return __a = __a ^ __b; }

  inline _Ios_Openmode

  operator~(_Ios_Openmode __a)

  { return _Ios_Openmode(~static_cast(__a)); }

  enum _Ios_Iostate { _M_ios_iostate_end = 1L << 16 };

  inline _Ios_Iostate

  operator&(_Ios_Iostate __a, _Ios_Iostate __b)

  { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); }

  inline _Ios_Iostate

  operator|(_Ios_Iostate __a, _Ios_Iostate __b)

  { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); }

  inline _Ios_Iostate

  operator^(_Ios_Iostate __a, _Ios_Iostate __b)

  { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); }

  inline _Ios_Iostate

  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)

  { return __a = __a | __b; }

  inline _Ios_Iostate

  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)

  { return __a = __a & __b; }

  inline _Ios_Iostate

  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)

  { return __a = __a ^ __b; }

  inline _Ios_Iostate

  operator~(_Ios_Iostate __a)

  { return _Ios_Iostate(~static_cast(__a)); }

  enum _Ios_Seekdir { _M_ios_seekdir_end = 1L << 16 };

  // 27.4.2  Class ios_base

  class ios_base

  {

  public:

    // 27.4.2.1.1  Class ios_base::failure

    class failure : public exception

    {

    public:

#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS

      // Can't do exception(_msg) as defined in 27.4.2.1.1

      explicit

      failure(const string& __str) throw();

      virtual

      ~failure() throw();

      virtual const char*

      what() const throw();

    private:

      enum { _M_bufsize = 256 };

      char _M_name[_M_bufsize];

#endif

    };

    // 27.4.2.1.2  Type ios_base::fmtflags

    typedef _Ios_Fmtflags fmtflags;

    // 27.4.2.1.2  Type fmtflags

    static const fmtflags boolalpha =   fmtflags(__ios_flags::_S_boolalpha);

    static const fmtflags dec =         fmtflags(__ios_flags::_S_dec);

    static const fmtflags fixed =       fmtflags(__ios_flags::_S_fixed);

    static const fmtflags hex =         fmtflags(__ios_flags::_S_hex);

    static const fmtflags internal =    fmtflags(__ios_flags::_S_internal);

    static const fmtflags left =        fmtflags(__ios_flags::_S_left);

    static const fmtflags oct =         fmtflags(__ios_flags::_S_oct);

    static const fmtflags right =       fmtflags(__ios_flags::_S_right);

    static const fmtflags scientific =  fmtflags(__ios_flags::_S_scientific);

    static const fmtflags showbase =    fmtflags(__ios_flags::_S_showbase);

    static const fmtflags showpoint =   fmtflags(__ios_flags::_S_showpoint);

    static const fmtflags showpos =     fmtflags(__ios_flags::_S_showpos);

    static const fmtflags skipws =      fmtflags(__ios_flags::_S_skipws);

    static const fmtflags unitbuf =     fmtflags(__ios_flags::_S_unitbuf);

    static const fmtflags uppercase =   fmtflags(__ios_flags::_S_uppercase);

    static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);

    static const fmtflags basefield =   fmtflags(__ios_flags::_S_basefield);

    static const fmtflags floatfield =  fmtflags(__ios_flags::_S_floatfield);

    // 27.4.2.1.3  Type ios_base::iostate

    typedef _Ios_Iostate iostate;

    static const iostate badbit =  	iostate(__ios_flags::_S_badbit);

    static const iostate eofbit =  	iostate(__ios_flags::_S_eofbit);

    static const iostate failbit = 	iostate(__ios_flags::_S_failbit);

    static const iostate goodbit = 	iostate(0);

    // 27.4.2.1.4  Type openmode

    typedef _Ios_Openmode openmode;

    static const openmode app =    	openmode(__ios_flags::_S_app);

    static const openmode ate =    	openmode(__ios_flags::_S_ate);

    static const openmode binary = 	openmode(__ios_flags::_S_bin);

    static const openmode in =     	openmode(__ios_flags::_S_in);

    static const openmode out =    	openmode(__ios_flags::_S_out);

    static const openmode trunc =  	openmode(__ios_flags::_S_trunc);

    // 27.4.2.1.5  Type seekdir

    typedef _Ios_Seekdir seekdir;

    static const seekdir beg = 		seekdir(0);

    static const seekdir cur = 		seekdir(SEEK_CUR);

    static const seekdir end = 		seekdir(SEEK_END);

#ifdef _GLIBCPP_DEPRECATED

    typedef int io_state;

    typedef int open_mode;

    typedef int seek_dir;

#endif

    // Callbacks;

    enum event

    {

      erase_event,

      imbue_event,

      copyfmt_event

    };

    typedef void (*event_callback) (event, ios_base&, int);

    void

    register_callback(event_callback __fn, int __index);

  protected:

    // Data Members

    streamsize 		_M_precision;

    streamsize 		_M_width;

    fmtflags 		_M_flags;

    // 27.4.2.6  Members for callbacks

    // 27.4.2.6  ios_base callbacks

    struct _Callback_list

    {

      // Data Members

      _Callback_list* 		_M_next;

      ios_base::event_callback 	_M_fn;

      int 			_M_index;

      int 			_M_refcount;  // 0 means one reference.

      _Callback_list(ios_base::event_callback __fn, int __index,

		     _Callback_list* __cb)

      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void

      _M_add_reference() { ++_M_refcount; } // XXX MT

      int

      _M_remove_reference() { return _M_refcount--; }  // 0 => OK to delete

    };

     _Callback_list*  	_M_callbacks;

    void

    _M_call_callbacks(event __ev) throw();

    void

    _M_dispose_callbacks(void);

    // 27.4.2.5  Members for iword/pword storage

    struct _Words

    {

      void* 	_M_pword;

      long 	_M_iword;

    };

    static const int 	_S_local_words = 8;

    _Words  		_M_word_array[_S_local_words];  // Guaranteed storage

    _Words  		_M_dummy;    // Only for failed iword/pword calls.

    _Words* 		_M_words;

    int     		_M_word_limit;

    _Words&

    _M_grow_words(int __index);

    // Members for locale and locale caching.

    locale 		_M_ios_locale;

    void

    _M_init();

  public:

    // 27.4.2.1.6  Class ios_base::Init

    // Used to initialize standard streams. In theory, g++ could use

    // -finit-priority to order this stuff correctly without going

    // through these machinations.

    class Init

    {

      friend class ios_base;

    public:

      Init();

      ~Init();

      static void

      _S_ios_create(bool __sync);

      static void

      _S_ios_destroy();

    private:

      static int 	_S_ios_base_init;

      static bool	_S_synced_with_stdio;

    };

    // Fmtflags state:

    inline fmtflags

    flags() const { return _M_flags; }

    inline fmtflags

    flags(fmtflags __fmtfl)

    {

      fmtflags __old = _M_flags;

      _M_flags = __fmtfl;

      return __old;

    }

    inline fmtflags

    setf(fmtflags __fmtfl)

    {

      fmtflags __old = _M_flags;

      _M_flags |= __fmtfl;

      return __old;

    }

    inline fmtflags

    setf(fmtflags __fmtfl, fmtflags __mask)

    {

      fmtflags __old = _M_flags;

      _M_flags &= ~__mask;

      _M_flags |= (__fmtfl & __mask);

      return __old;

    }

    inline void

    unsetf(fmtflags __mask) { _M_flags &= ~__mask; }

    inline streamsize

    precision() const { return _M_precision; }

    inline streamsize

    precision(streamsize __prec)

    {

      streamsize __old = _M_precision;

      _M_precision = __prec;

      return __old;

    }

    inline streamsize

    width() const { return _M_width; }

    inline streamsize

    width(streamsize __wide)

    {

      streamsize __old = _M_width;

      _M_width = __wide;

      return __old;

    }

    static bool

    sync_with_stdio(bool __sync = true);

    // Locales:

    locale

    imbue(const locale& __loc);

    inline locale

    getloc() const { return _M_ios_locale; }

    // Storage:

    static int

    xalloc() throw();

    inline long&

    iword(int __ix)

    {

      _Words& __word = (__ix < _M_word_limit)

			? _M_words[__ix] : _M_grow_words(__ix);

      return __word._M_iword;

    }

    inline void*&

    pword(int __ix)

    {

      _Words& __word = (__ix < _M_word_limit)

			? _M_words[__ix] : _M_grow_words(__ix);

      return __word._M_pword;

    }

    // Destructor

    ~ios_base();

  protected:

    ios_base();

#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS

  private:

    ios_base(const ios_base&);

    ios_base&

    operator=(const ios_base&);

#endif

  };

  // 27.4.5.1 fmtflags manipulators:

  inline ios_base&

  boolalpha(ios_base& __base)

  {

    __base.setf(ios_base::boolalpha);

    return __base;

  }

  inline ios_base&

  noboolalpha(ios_base& __base)

  {

    __base.unsetf(ios_base::boolalpha);

    return __base;

  }

  inline ios_base&

  showbase(ios_base& __base)

  {

    __base.setf(ios_base::showbase);

    return __base;

  }

  inline ios_base&

  noshowbase(ios_base& __base)

  {

    __base.unsetf(ios_base::showbase);

    return __base;

  }

  inline ios_base&

  showpoint(ios_base& __base)

  {

    __base.setf(ios_base::showpoint);

    return __base;

  }

  inline ios_base&

  noshowpoint(ios_base& __base)

  {

    __base.unsetf(ios_base::showpoint);

    return __base;

  }

  inline ios_base&

  showpos(ios_base& __base)

  {

    __base.setf(ios_base::showpos);

    return __base;

  }

  inline ios_base&

  noshowpos(ios_base& __base)

  {

    __base.unsetf(ios_base::showpos);

    return __base;

  }

  inline ios_base&

  skipws(ios_base& __base)

  {

    __base.setf(ios_base::skipws);

    return __base;

  }

  inline ios_base&

  noskipws(ios_base& __base)

  {

    __base.unsetf(ios_base::skipws);

    return __base;

  }

  inline ios_base&

  uppercase(ios_base& __base)

  {

    __base.setf(ios_base::uppercase);

    return __base;

  }

  inline ios_base&

  nouppercase(ios_base& __base)

  {

    __base.unsetf(ios_base::uppercase);

    return __base;

  }

  inline ios_base&

  unitbuf(ios_base& __base)

  {

     __base.setf(ios_base::unitbuf);

     return __base;

  }

  inline ios_base&

  nounitbuf(ios_base& __base)

  {

     __base.unsetf(ios_base::unitbuf);

     return __base;

  }

  // 27.4.5.2 adjustfield anipulators:

  inline ios_base&

  internal(ios_base& __base)

  {

     __base.setf(ios_base::internal, ios_base::adjustfield);

     return __base;

  }

  inline ios_base&

  left(ios_base& __base)

  {

    __base.setf(ios_base::left, ios_base::adjustfield);

    return __base;

  }

  inline ios_base&

  right(ios_base& __base)

  {

    __base.setf(ios_base::right, ios_base::adjustfield);

    return __base;

  }

  // 27.4.5.3 basefield anipulators:

  inline ios_base&

  dec(ios_base& __base)

  {

    __base.setf(ios_base::dec, ios_base::basefield);

    return __base;

  }

  inline ios_base&

  hex(ios_base& __base)

  {

    __base.setf(ios_base::hex, ios_base::basefield);

    return __base;

  }

  inline ios_base&

  oct(ios_base& __base)

  {

    __base.setf(ios_base::oct, ios_base::basefield);

    return __base;

  }

  // 27.4.5.4 floatfield anipulators:

  inline ios_base&

  fixed(ios_base& __base)

  {

    __base.setf(ios_base::fixed, ios_base::floatfield);

    return __base;

  }

  inline ios_base&

  scientific(ios_base& __base)

  {

    __base.setf(ios_base::scientific, ios_base::floatfield);

    return __base;

  }

} // namespace std

#endif /* _CPP_BITS_IOSBASE_H */