/*

  * 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: