/*

 * Copyright (c) 1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

#ifndef _STLP_IOS_BASE_H

#define _STLP_IOS_BASE_H

#ifndef _STLP_INTERNAL_STDEXCEPT_BASE

#  include <stl/_stdexcept_base.h>

#endif

#ifndef _STLP_UTILITY

#  include <utility>

#endif

#ifndef _STLP_INTERNAL_LOCALE_H

#  include <stl/_locale.h>

#endif

#ifndef _STLP_INTERNAL_STRING_H

#  include <stl/_string.h>

#endif

_STLP_BEGIN_NAMESPACE

// ----------------------------------------------------------------------

// Class ios_base.  This is the base class of the ios hierarchy, which

// includes basic_istream and basic_ostream.  Classes in the ios

// hierarchy are actually quite simple: they are just glorified

// wrapper classes.  They delegate buffering and physical character

// manipulation to the streambuf classes, and they delegate most

// formatting tasks to a locale.

class _STLP_CLASS_DECLSPEC ios_base {

public:

  class _STLP_CLASS_DECLSPEC failure : public __Named_exception {

  public:

    explicit failure(const string&);

    virtual ~failure() _STLP_NOTHROW_INHERENTLY;

  };

  typedef int fmtflags;

  typedef int iostate;

  typedef int openmode;

  typedef int seekdir;

# ifndef _STLP_NO_ANACHRONISMS

  typedef fmtflags fmt_flags;

# endif

  // Formatting flags.

#if defined (_STLP_STATIC_CONST_INIT_BUG)

  enum  {

#else

  // boris : type for all those constants is int

  static const int

#endif

    left       = 0x0001,

    right      = 0x0002,

    internal   = 0x0004,

    dec        = 0x0008,

    hex        = 0x0010,

    oct        = 0x0020,

    fixed      = 0x0040,

    scientific = 0x0080,

    boolalpha  = 0x0100,

    showbase   = 0x0200,

    showpoint  = 0x0400,

    showpos    = 0x0800,

    skipws     = 0x1000,

    unitbuf    = 0x2000,

    uppercase  = 0x4000,

    adjustfield = left | right | internal,

    basefield   = dec | hex | oct,

    floatfield  = scientific | fixed,

    // State flags.

    goodbit = 0x00,

    badbit  = 0x01,

    eofbit  = 0x02,

    failbit = 0x04,

    // Openmode flags.

    __default_mode = 0x0, /* implementation detail */

    app    = 0x01,

    ate    = 0x02,

    binary = 0x04,

    in     = 0x08,

    out    = 0x10,

    trunc  = 0x20,

    // Seekdir flags

    beg = 0x01,

    cur = 0x02,

    end = 0x04

# ifdef _STLP_STATIC_CONST_INIT_BUG

  }

# endif

  ;

public:                         // Flag-manipulation functions.

  fmtflags flags() const { return _M_fmtflags; }

  fmtflags flags(fmtflags __flags) {

    fmtflags __tmp = _M_fmtflags;

    _M_fmtflags = __flags;

    return __tmp;

  }

  fmtflags setf(fmtflags __flag) {

    fmtflags __tmp = _M_fmtflags;

    _M_fmtflags |= __flag;

    return __tmp;

  }

  fmtflags setf(fmtflags __flag, fmtflags __mask) {

    fmtflags __tmp = _M_fmtflags;

    _M_fmtflags &= ~__mask;

    _M_fmtflags |= __flag & __mask;

    return __tmp;

  }

  void unsetf(fmtflags __mask) { _M_fmtflags &= ~__mask; }

  streamsize precision() const { return _M_precision; }

  streamsize precision(streamsize __newprecision) {

    streamsize __tmp = _M_precision;

    _M_precision = __newprecision;

    return __tmp;

  }

  streamsize width() const { return _M_width; }

  streamsize width(streamsize __newwidth) {

    streamsize __tmp = _M_width;

    _M_width = __newwidth;

    return __tmp;

  }

public:                         // Locales

  locale imbue(const locale&);

  locale getloc() const { return _M_locale; }

public:                         // Auxiliary storage.

  static int _STLP_CALL xalloc();

  long&  iword(int __index);

  void*& pword(int __index);

public:                         // Destructor.

  virtual ~ios_base();

public:                         // Callbacks.

  enum event { erase_event, imbue_event, copyfmt_event };

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

  void register_callback(event_callback __fn, int __index);

public:                         // This member function affects only

                                // the eight predefined ios objects:

                                // cin, cout, etc.

  static bool _STLP_CALL sync_with_stdio(bool __sync = true);

public:                         // The C++ standard requires only that these

                                // member functions be defined in basic_ios.

                                // We define them in the non-template

                                // base class to avoid code duplication.

  operator void*() const { return !fail() ? (void*) __CONST_CAST(ios_base*,this) : (void*) 0; }

  bool operator!() const { return fail(); }

  iostate rdstate() const { return _M_iostate; }

  bool good() const { return _M_iostate == 0; }

  bool eof() const { return (_M_iostate & eofbit) != 0; }

  bool fail() const { return (_M_iostate & (failbit | badbit)) != 0; }

  bool bad() const { return (_M_iostate & badbit) != 0; }

protected:                      // The functional protected interface.

  // Copies the state of __x to *this.  This member function makes it

  // possible to implement basic_ios::copyfmt without having to expose

  // ios_base's private data members.  Does not copy _M_exception_mask

  // or _M_iostate.

  void _M_copy_state(const ios_base& __x);

  void _M_setstate_nothrow(iostate __state) { _M_iostate |= __state; }

  void _M_clear_nothrow(iostate __state) { _M_iostate = __state; }

  iostate _M_get_exception_mask() const { return _M_exception_mask; }

  void _M_set_exception_mask(iostate __mask) { _M_exception_mask = __mask; }

  void _M_check_exception_mask() {

    if (_M_iostate & _M_exception_mask)

      _M_throw_failure();

  }

  void _M_invoke_callbacks(event);

  void _STLP_FUNCTION_THROWS _M_throw_failure();

  ios_base();                   // Default constructor.

protected:                        // Initialization of the I/O system

  static void _STLP_CALL _S_initialize();

  static void _STLP_CALL _S_uninitialize();

  static bool _S_was_synced;

private:                        // Invalidate the copy constructor and

                                // assignment operator.

  ios_base(const ios_base&);

  void operator=(const ios_base&);

private:                        // Data members.

  fmtflags _M_fmtflags;         // Flags

  iostate _M_iostate;

  openmode _M_openmode;

  seekdir _M_seekdir;

  iostate _M_exception_mask;

  streamsize _M_precision;

  streamsize _M_width;

  locale _M_locale;

  pair<event_callback, int>* _M_callbacks;

  size_t _M_num_callbacks;      // Size of the callback array.

  size_t _M_callback_index;     // Index of the next available callback;

                                // initially zero.

  long* _M_iwords;              // Auxiliary storage.  The count is zero

  size_t _M_num_iwords;         // if and only if the pointer is null.

  void** _M_pwords;

  size_t _M_num_pwords;

protected:

  // Cached copies of the curent locale's facets.  Set by init() and imbue().

  locale::facet* _M_cached_ctype;

  locale::facet* _M_cached_numpunct;

  string         _M_cached_grouping;

public:

  // Equivalent to &use_facet< Facet >(getloc()), but faster.

  const locale::facet* _M_ctype_facet() const { return _M_cached_ctype; }

  const locale::facet* _M_numpunct_facet() const { return _M_cached_numpunct; }

  const string&  _M_grouping() const { return _M_cached_grouping; }

public:

  // ----------------------------------------------------------------------

  // Nested initializer class.  This is an implementation detail, but it's

  // prescribed by the standard.  The static initializer object (on

  // implementations where such a thing is required) is declared in

  // <iostream>

  class _STLP_CLASS_DECLSPEC Init

  {

    public:

      Init();

      ~Init();

    private:

      static long _S_count;

      friend class ios_base;

  };

  friend class Init;

public:

# ifndef _STLP_NO_ANACHRONISMS

  //  31.6  Old iostreams members                         [depr.ios.members]

  typedef iostate  io_state;

  typedef openmode open_mode;

  typedef seekdir  seek_dir;

  typedef _STLP_STD::streamoff  streamoff;

  typedef _STLP_STD::streampos  streampos;

# endif

};

// ----------------------------------------------------------------------

// ios_base manipulator functions, from section 27.4.5 of the C++ standard.

// All of them are trivial one-line wrapper functions.

// fmtflag manipulators, section 27.4.5.1

inline ios_base& _STLP_CALL boolalpha(ios_base& __s)

  { __s.setf(ios_base::boolalpha); return __s;}

inline ios_base& _STLP_CALL noboolalpha(ios_base& __s)

  { __s.unsetf(ios_base::boolalpha); return __s;}

inline ios_base& _STLP_CALL showbase(ios_base& __s)

  { __s.setf(ios_base::showbase); return __s;}

inline ios_base& _STLP_CALL noshowbase(ios_base& __s)

  { __s.unsetf(ios_base::showbase); return __s;}

inline ios_base& _STLP_CALL showpoint(ios_base& __s)

  { __s.setf(ios_base::showpoint); return __s;}

inline ios_base& _STLP_CALL noshowpoint(ios_base& __s)

  { __s.unsetf(ios_base::showpoint); return __s;}

inline ios_base& _STLP_CALL showpos(ios_base& __s)

  { __s.setf(ios_base::showpos); return __s;}

inline ios_base& _STLP_CALL noshowpos(ios_base& __s)

  { __s.unsetf(ios_base::showpos); return __s;}

inline ios_base& _STLP_CALL skipws(ios_base& __s)

  { __s.setf(ios_base::skipws); return __s;}

inline ios_base& _STLP_CALL noskipws(ios_base& __s)

  { __s.unsetf(ios_base::skipws); return __s;}

inline ios_base& _STLP_CALL uppercase(ios_base& __s)

  { __s.setf(ios_base::uppercase); return __s;}

inline ios_base& _STLP_CALL nouppercase(ios_base& __s)

  { __s.unsetf(ios_base::uppercase); return __s;}

inline ios_base& _STLP_CALL unitbuf(ios_base& __s)

  { __s.setf(ios_base::unitbuf); return __s;}

inline ios_base& _STLP_CALL nounitbuf(ios_base& __s)

  { __s.unsetf(ios_base::unitbuf); return __s;}

// adjustfield manipulators, section 27.4.5.2

inline ios_base& _STLP_CALL internal(ios_base& __s)

  { __s.setf(ios_base::internal, ios_base::adjustfield); return __s; }

inline ios_base& _STLP_CALL left(ios_base& __s)

  { __s.setf(ios_base::left, ios_base::adjustfield); return __s; }

inline ios_base& _STLP_CALL right(ios_base& __s)

  { __s.setf(ios_base::right, ios_base::adjustfield); return __s; }

// basefield manipulators, section 27.4.5.3

inline ios_base& _STLP_CALL dec(ios_base& __s)

  { __s.setf(ios_base::dec, ios_base::basefield); return __s; }

inline ios_base& _STLP_CALL hex(ios_base& __s)

  { __s.setf(ios_base::hex, ios_base::basefield); return __s; }

inline ios_base& _STLP_CALL oct(ios_base& __s)

  { __s.setf(ios_base::oct, ios_base::basefield); return __s; }

// floatfield manipulators, section 27.4.5.3

inline ios_base& _STLP_CALL fixed(ios_base& __s)

  { __s.setf(ios_base::fixed, ios_base::floatfield); return __s; }

inline ios_base& _STLP_CALL scientific(ios_base& __s)

  { __s.setf(ios_base::scientific, ios_base::floatfield); return __s; }

_STLP_END_NAMESPACE

#endif /* _STLP_IOS_BASE */

// Local Variables:

// mode:C++

// End: