include/c++/stl/stl/_fstream.h

   1 /*
   2  * Copyright (c) 1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18 // This header defines classes basic_filebuf, basic_ifstream,
  19 // basic_ofstream, and basic_fstream.  These classes represent
  20 // streambufs and streams whose sources or destinations are files.
  21
  22 #ifndef _STLP_INTERNAL_FSTREAM_H
  23 #define _STLP_INTERNAL_FSTREAM_H
  24
  25 #if defined(__sgi) && !defined(__GNUC__) && !defined(_STANDARD_C_PLUS_PLUS)
  26 #  error This header file requires the -LANG:std option
  27 #endif
  28
  29 #ifndef _STLP_INTERNAL_STREAMBUF
  30 #  include <stl/_streambuf.h>
  31 #endif
  32
  33 #ifndef _STLP_INTERNAL_ISTREAM
  34 #  include <stl/_istream.h>
  35 #endif
  36
  37 #ifndef _STLP_INTERNAL_CODECVT_H
  38 #  include <stl/_codecvt.h>
  39 #endif
  40
  41 #if !defined (_STLP_USE_UNIX_IO) && !defined(_STLP_USE_WIN32_IO) && \
  42     !defined (_STLP_USE_UNIX_EMULATION_IO) && !defined (_STLP_USE_STDIO_IO)
  43
  44 #  if defined (_STLP_UNIX)  || defined (__CYGWIN__) || defined (__amigaos__) || defined (__EMX__)
  45 // open/close/read/write
  46 #    define _STLP_USE_UNIX_IO
  47 #  elif defined (_STLP_WIN32)
  48 // CreateFile/ReadFile/WriteFile
  49 #    define _STLP_USE_WIN32_IO
  50 #  elif defined (_STLP_WIN16) || defined (_STLP_MAC)
  51 // _open/_read/_write
  52 #    define _STLP_USE_UNIX_EMULATION_IO
  53 #  else
  54 // fopen/fread/fwrite
  55 #    define _STLP_USE_STDIO_IO
  56 #  endif /* _STLP_UNIX */
  57 #endif /* mode selection */
  58
  59 #if defined (_STLP_USE_WIN32_IO)
  60 typedef void* _STLP_fd;
  61 #elif defined (_STLP_USE_UNIX_EMULATION_IO) || defined (_STLP_USE_STDIO_IO) || defined (_STLP_USE_UNIX_IO)
  62 typedef int _STLP_fd;
  63 #else
  64 #  error "Configure i/o !"
  65 #endif
  66
  67 _STLP_BEGIN_NAMESPACE
  68
  69 //----------------------------------------------------------------------
  70 // Class _Filebuf_base, a private base class to factor out the system-
  71 // dependent code from basic_filebuf<>.
  72
  73 class _STLP_CLASS_DECLSPEC _Filebuf_base {
  74 public:                      // Opening and closing files.
  75   _Filebuf_base();
  76
  77   bool _M_open(const char*, ios_base::openmode, long __protection);
  78   bool _M_open(const char*, ios_base::openmode);
  79   bool _M_open(int __id, ios_base::openmode = ios_base::__default_mode);
  80 #if defined (_STLP_USE_WIN32_IO)
  81   bool _M_open(_STLP_fd __id, ios_base::openmode = ios_base::__default_mode);
  82 #endif /* _STLP_USE_WIN32_IO */
  83   bool _M_close();
  84
  85 public:                      // Low-level I/O, like Unix read/write
  86   ptrdiff_t _M_read(char* __buf,  ptrdiff_t __n);
  87   streamoff _M_seek(streamoff __offset, ios_base::seekdir __dir);
  88   streamoff _M_file_size();
  89   bool _M_write(char* __buf,  ptrdiff_t __n);
  90
  91 public:                      // Memory-mapped I/O.
  92   void* _M_mmap(streamoff __offset, streamoff __len);
  93   void _M_unmap(void* __mmap_base, streamoff __len);
  94
  95 public:
  96   // Returns a value n such that, if pos is the file pointer at the
  97   // beginning of the range [first, last), pos + n is the file pointer at
  98   // the end.  On many operating systems n == __last - __first.
  99   // In Unix, writing n characters always bumps the file position by n.
 100   // In Windows text mode, however, it bumps the file position by n + m,
 101   // where m is the number of newlines in the range.  That's because an
 102   // internal \n corresponds to an external two-character sequence.
 103   streamoff _M_get_offset(char* __first, char* __last) {
 104 #if defined (_STLP_UNIX) || defined (_STLP_MAC)
 105     return __last - __first;
 106 #else // defined (_STLP_WIN32) || defined (_STLP_WIN16) || defined (_STLP_DOS) || defined(N_PLAT_NLM)
 107     return ( (_M_openmode & ios_base::binary) != 0 )
 108       ? (__last - __first)
 109       : count(__first, __last, '\n') + (__last - __first);
 110 #endif
 111   }
 112
 113   // Returns true if we're in binary mode or if we're using an OS or file
 114   // system where there is no distinction between text and binary mode.
 115   bool _M_in_binary_mode() const {
 116 #if defined (_STLP_UNIX) || defined (_STLP_MAC)  || defined(__BEOS__) || defined (__amigaos__)
 117     return true;
 118 #elif defined (_STLP_WIN32) || defined (_STLP_WIN16) || defined (_STLP_DOS) || defined (_STLP_VM) || defined (__EMX__) || defined(N_PLAT_NLM)
 119     return (_M_openmode & ios_base::binary) != 0;
 120 #else
 121 #  error "Port!"
 122 #endif
 123   }
 124
 125   static void _S_initialize();
 126
 127 protected:                      // Static data members.
 128   static size_t _M_page_size;
 129
 130 protected:                      // Data members.
 131   _STLP_fd _M_file_id;
 132 #if defined (_STLP_USE_STDIO_IO)
 133   // for stdio, the whole FILE* is being kept here
 134   FILE* _M_file;
 135 #endif
 136 #if defined (_STLP_USE_WIN32_IO)
 137   _STLP_fd _M_view_id;
 138 #endif
 139
 140   ios_base::openmode _M_openmode     ;
 141   unsigned char      _M_is_open      ;
 142   unsigned char      _M_should_close ;
 143   unsigned char      _M_regular_file ;
 144
 145 public :
 146   static size_t  _STLP_CALL __page_size() { return _M_page_size; }
 147   int  __o_mode() const { return (int)_M_openmode; }
 148   bool __is_open()      const { return (_M_is_open !=0 ); }
 149   bool __should_close() const { return (_M_should_close != 0); }
 150   bool __regular_file() const { return (_M_regular_file != 0); }
 151   _STLP_fd __get_fd() const { return _M_file_id; }
 152 };
 153
 154 //----------------------------------------------------------------------
 155 // Class basic_filebuf<>.
 156
 157 // Forward declaration of two helper classes.
 158 template <class _Traits> class _Noconv_input;
 159 _STLP_TEMPLATE_NULL
 160 class _Noconv_input<char_traits<char> >;
 161
 162 template <class _Traits> class _Noconv_output;
 163 _STLP_TEMPLATE_NULL
 164 class _Noconv_output< char_traits<char> >;
 165
 166 // There is a specialized version of underflow, for basic_filebuf<char>,
 167 // in fstream.cxx.
 168
 169 template <class _CharT, class _Traits>
 170 class _Underflow;
 171
 172 _STLP_TEMPLATE_NULL class _Underflow< char, char_traits<char> >;
 173
 174 template <class _CharT, class _Traits>
 175 class basic_filebuf : public basic_streambuf<_CharT, _Traits> {
 176 public:                         // Types.
 177   typedef _CharT                     char_type;
 178   typedef typename _Traits::int_type int_type;
 179   typedef typename _Traits::pos_type pos_type;
 180   typedef typename _Traits::off_type off_type;
 181   typedef _Traits                    traits_type;
 182
 183   typedef typename _Traits::state_type _State_type;
 184   typedef basic_streambuf<_CharT, _Traits> _Base;
 185   typedef basic_filebuf<_CharT, _Traits> _Self;
 186
 187 public:                         // Constructors, destructor.
 188   basic_filebuf();
 189   ~basic_filebuf();
 190
 191 public:                         // Opening and closing files.
 192   bool is_open() const { return _M_base.__is_open(); }
 193
 194   _Self* open(const char* __s, ios_base::openmode __m) {
 195     return _M_base._M_open(__s, __m) ? this : 0;
 196   }
 197
 198 #if !defined (_STLP_NO_EXTENSIONS)
 199   // These two version of open() and file descriptor getter are extensions.
 200   _Self* open(const char* __s, ios_base::openmode __m,
 201               long __protection) {
 202     return _M_base._M_open(__s, __m, __protection) ? this : 0;
 203   }
 204
 205   _STLP_fd fd() const { return _M_base.__get_fd(); }
 206
 207   _Self* open(int __id, ios_base::openmode _Init_mode = ios_base::__default_mode) {
 208     return this->_M_open(__id, _Init_mode);
 209   }
 210
 211 #  if defined (_STLP_USE_WIN32_IO)
 212   _Self* open(_STLP_fd __id, ios_base::openmode _Init_mode = ios_base::__default_mode) {
 213     return _M_base._M_open(__id, _Init_mode) ? this : 0;
 214   }
 215 #  endif /* _STLP_USE_WIN32_IO */
 216
 217 #endif
 218
 219   _Self* _M_open(int __id, ios_base::openmode _Init_mode = ios_base::__default_mode) {
 220     return _M_base._M_open(__id, _Init_mode) ? this : 0;
 221   }
 222
 223   _Self* close();
 224
 225 protected:                      // Virtual functions from basic_streambuf.
 226   virtual streamsize showmanyc();
 227   virtual int_type underflow();
 228
 229   virtual int_type pbackfail(int_type = traits_type::eof());
 230   virtual int_type overflow(int_type = traits_type::eof());
 231
 232   virtual basic_streambuf<_CharT, _Traits>* setbuf(char_type*, streamsize);
 233   virtual pos_type seekoff(off_type, ios_base::seekdir,
 234                            ios_base::openmode = ios_base::in | ios_base::out);
 235   virtual pos_type seekpos(pos_type,
 236                            ios_base::openmode = ios_base::in | ios_base::out);
 237
 238   virtual int sync();
 239   virtual void imbue(const locale&);
 240
 241 private:                        // Helper functions.
 242
 243   // Precondition: we are currently in putback input mode.  Effect:
 244   // switches back to ordinary input mode.
 245   void _M_exit_putback_mode() {
 246     this->setg(_M_saved_eback, _M_saved_gptr, _M_saved_egptr);
 247     _M_in_putback_mode = false;
 248   }
 249   bool _M_switch_to_input_mode();
 250   void _M_exit_input_mode();
 251   bool _M_switch_to_output_mode();
 252
 253   int_type _M_input_error();
 254   int_type _M_underflow_aux();
 255   //  friend class _Noconv_input<_Traits>;
 256   //  friend class _Noconv_output<_Traits>;
 257   friend class _Underflow<_CharT, _Traits>;
 258
 259   int_type _M_output_error();
 260   bool _M_unshift();
 261
 262   bool _M_allocate_buffers(_CharT* __buf, streamsize __n);
 263   bool _M_allocate_buffers();
 264   void _M_deallocate_buffers();
 265
 266   pos_type _M_seek_return(off_type __off, _State_type __state) {
 267     if (__off != -1) {
 268       if (_M_in_input_mode)
 269         _M_exit_input_mode();
 270       _M_in_input_mode = false;
 271       _M_in_output_mode = false;
 272       _M_in_putback_mode = false;
 273       _M_in_error_mode = false;
 274       this->setg(0, 0, 0);
 275       this->setp(0, 0);
 276     }
 277
 278     pos_type __result(__off);
 279     __result.state(__state);
 280     return __result;
 281   }
 282
 283   bool _M_seek_init(bool __do_unshift);
 284
 285   void _M_setup_codecvt(const locale&, bool __on_imbue = true);
 286
 287 private:                        // Data members used in all modes.
 288
 289   _Filebuf_base _M_base;
 290
 291 private:                        // Locale-related information.
 292
 293   unsigned char _M_constant_width;
 294   unsigned char _M_always_noconv;
 295
 296   // private:                        // Mode flags.
 297   unsigned char _M_int_buf_dynamic;  // True if internal buffer is heap allocated,
 298   // false if it was supplied by the user.
 299   unsigned char _M_in_input_mode;
 300   unsigned char _M_in_output_mode;
 301   unsigned char _M_in_error_mode;
 302   unsigned char _M_in_putback_mode;
 303
 304   // Internal buffer: characters seen by the filebuf's clients.
 305   _CharT* _M_int_buf;
 306   _CharT* _M_int_buf_EOS;
 307
 308   // External buffer: characters corresponding to the external file.
 309   char* _M_ext_buf;
 310   char* _M_ext_buf_EOS;
 311
 312   // The range [_M_ext_buf, _M_ext_buf_converted) contains the external
 313   // characters corresponding to the sequence in the internal buffer.  The
 314   // range [_M_ext_buf_converted, _M_ext_buf_end) contains characters that
 315   // have been read into the external buffer but have not been converted
 316   // to an internal sequence.
 317   char* _M_ext_buf_converted;
 318   char* _M_ext_buf_end;
 319
 320   // State corresponding to beginning of internal buffer.
 321   _State_type _M_state;
 322
 323 private:                        // Data members used only in input mode.
 324
 325   // Similar to _M_state except that it corresponds to
 326   // the end of the internal buffer instead of the beginning.
 327   _State_type _M_end_state;
 328
 329   // This is a null pointer unless we are in mmap input mode.
 330   void*     _M_mmap_base;
 331   streamoff _M_mmap_len;
 332
 333 private:                        // Data members used only in putback mode.
 334   _CharT* _M_saved_eback;
 335   _CharT* _M_saved_gptr;
 336   _CharT* _M_saved_egptr;
 337
 338   typedef codecvt<_CharT, char, _State_type> _Codecvt;
 339   const _Codecvt* _M_codecvt;
 340
 341   int _M_width;                 // Width of the encoding (if constant), else 1
 342   int _M_max_width;             // Largest possible width of single character.
 343
 344
 345   enum { _S_pback_buf_size = 8 };
 346   _CharT _M_pback_buf[_S_pback_buf_size];
 347
 348   // for _Noconv_output
 349 public:
 350   bool _M_write(char* __buf,  ptrdiff_t __n) {return _M_base._M_write(__buf, __n); }
 351
 352 public:
 353   int_type
 354   _M_do_noconv_input() {
 355     _M_ext_buf_converted = _M_ext_buf_end;
 356     /* this-> */ _Base::setg((char_type*)_M_ext_buf, (char_type*)_M_ext_buf, (char_type*)_M_ext_buf_end);
 357     return traits_type::to_int_type(*_M_ext_buf);
 358   }
 359 };
 360
 361 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 362 _STLP_EXPORT_TEMPLATE_CLASS basic_filebuf<char, char_traits<char> >;
 363 #  if ! defined (_STLP_NO_WCHAR_T)
 364 _STLP_EXPORT_TEMPLATE_CLASS basic_filebuf<wchar_t, char_traits<wchar_t> >;
 365 #  endif
 366 #endif /* _STLP_USE_TEMPLATE_EXPORT */
 367
 368 // public:
 369 // helper class.
 370 template <class _CharT>
 371 struct _Filebuf_Tmp_Buf {
 372   _CharT* _M_ptr;
 373   _Filebuf_Tmp_Buf(ptrdiff_t __n) : _M_ptr(0) { _M_ptr = new _CharT[__n]; }
 374   ~_Filebuf_Tmp_Buf() { delete[] _M_ptr; }
 375 };
 376
 377
 378 //
 379 // This class had to be designed very carefully to work
 380 // with Visual C++.
 381 //
 382 template <class _Traits>
 383 class _Noconv_output {
 384 public:
 385   typedef typename _Traits::char_type char_type;
 386   static bool  _STLP_CALL _M_doit(basic_filebuf<char_type, _Traits >*,
 387                                   char_type*, char_type*)
 388   { return false; }
 389 };
 390
 391 _STLP_TEMPLATE_NULL
 392 class _STLP_CLASS_DECLSPEC _Noconv_output< char_traits<char> > {
 393 public:
 394   static bool  _STLP_CALL
 395   _M_doit(basic_filebuf<char, char_traits<char> >* __buf,
 396           char* __first, char* __last) {
 397     ptrdiff_t __n = __last - __first;
 398     return (__buf->_M_write(__first, __n));
 399   }
 400 };
 401
 402 //----------------------------------------------------------------------
 403 // basic_filebuf<> helper functions.
 404
 405
 406 //----------------------------------------
 407 // Helper functions for switching between modes.
 408
 409 //
 410 // This class had to be designed very carefully to work
 411 // with Visual C++.
 412 //
 413 template <class _Traits>
 414 class _Noconv_input {
 415 public:
 416   typedef typename _Traits::int_type int_type;
 417   typedef typename _Traits::char_type char_type;
 418
 419   static inline int_type _STLP_CALL
 420   _M_doit(basic_filebuf<char_type, _Traits>*)
 421   { return _Traits::eof(); }
 422 };
 423
 424 _STLP_TEMPLATE_NULL
 425 class _Noconv_input<char_traits<char> > {
 426 public:
 427   static inline int _STLP_CALL
 428   _M_doit(basic_filebuf<char, char_traits<char> >* __buf) {
 429     return __buf->_M_do_noconv_input();
 430   }
 431 };
 432
 433 // underflow() may be called for one of two reasons.  (1) We've
 434 // been going through the special putback buffer, and we need to move back
 435 // to the regular internal buffer.  (2) We've exhausted the internal buffer,
 436 // and we need to replentish it.
 437 template <class _CharT, class _Traits>
 438 class _Underflow {
 439 public:
 440   typedef typename _Traits::int_type int_type;
 441   typedef _Traits                    traits_type;
 442
 443   static int_type _STLP_CALL _M_doit(basic_filebuf<_CharT, _Traits>* __this);
 444 };
 445
 446
 447 // Specialization of underflow: if the character type is char, maybe
 448 // we can use mmap instead of read.
 449 _STLP_TEMPLATE_NULL
 450 class _STLP_CLASS_DECLSPEC _Underflow< char, char_traits<char> > {
 451 public:
 452   typedef char_traits<char>::int_type int_type;
 453   typedef char_traits<char> traits_type;
 454   static  int _STLP_CALL _M_doit(basic_filebuf<char, traits_type >* __this);
 455 };
 456
 457 // There is a specialized version of underflow, for basic_filebuf<char>,
 458 // in fstream.cxx.
 459
 460 template <class _CharT, class _Traits>
 461 _STLP_TYPENAME_ON_RETURN_TYPE _Underflow<_CharT, _Traits>::int_type // _STLP_CALL
 462  _Underflow<_CharT, _Traits>::_M_doit(basic_filebuf<_CharT, _Traits>* __this) {
 463   if (!__this->_M_in_input_mode) {
 464     if (!__this->_M_switch_to_input_mode())
 465       return traits_type::eof();
 466   }
 467   else if (__this->_M_in_putback_mode) {
 468     __this->_M_exit_putback_mode();
 469     if (__this->gptr() != __this->egptr()) {
 470       int_type __c = traits_type::to_int_type(*__this->gptr());
 471       return __c;
 472     }
 473   }
 474
 475   return __this->_M_underflow_aux();
 476 }
 477
 478 #if defined (_STLP_USE_TEMPLATE_EXPORT) && !defined (_STLP_NO_WCHAR_T)
 479 _STLP_EXPORT_TEMPLATE_CLASS _Underflow<wchar_t, char_traits<wchar_t> >;
 480 #endif
 481
 482 //----------------------------------------------------------------------
 483 // Class basic_ifstream<>
 484
 485 template <class _CharT, class _Traits>
 486 class basic_ifstream : public basic_istream<_CharT, _Traits> {
 487 public:                         // Types
 488   typedef _CharT                     char_type;
 489   typedef typename _Traits::int_type int_type;
 490   typedef typename _Traits::pos_type pos_type;
 491   typedef typename _Traits::off_type off_type;
 492   typedef _Traits                    traits_type;
 493
 494   typedef basic_ios<_CharT, _Traits>                _Basic_ios;
 495   typedef basic_istream<_CharT, _Traits>            _Base;
 496   typedef basic_filebuf<_CharT, _Traits>            _Buf;
 497
 498 public:                         // Constructors, destructor.
 499
 500   basic_ifstream() :
 501     basic_ios<_CharT, _Traits>(),  basic_istream<_CharT, _Traits>(0), _M_buf() {
 502       this->init(&_M_buf);
 503   }
 504
 505   explicit basic_ifstream(const char* __s, ios_base::openmode __mod = ios_base::in) :
 506     basic_ios<_CharT, _Traits>(),  basic_istream<_CharT, _Traits>(0),
 507     _M_buf() {
 508       this->init(&_M_buf);
 509       if (!_M_buf.open(__s, __mod | ios_base::in))
 510         this->setstate(ios_base::failbit);
 511   }
 512
 513 #if !defined (_STLP_NO_EXTENSIONS)
 514   explicit basic_ifstream(int __id, ios_base::openmode __mod = ios_base::in) :
 515     basic_ios<_CharT, _Traits>(),  basic_istream<_CharT, _Traits>(0), _M_buf() {
 516     this->init(&_M_buf);
 517     if (!_M_buf.open(__id, __mod | ios_base::in))
 518       this->setstate(ios_base::failbit);
 519   }
 520   basic_ifstream(const char* __s, ios_base::openmode __m,
 521      long __protection) :
 522     basic_ios<_CharT, _Traits>(),  basic_istream<_CharT, _Traits>(0), _M_buf() {
 523     this->init(&_M_buf);
 524     if (!_M_buf.open(__s, __m | ios_base::in, __protection))
 525       this->setstate(ios_base::failbit);
 526   }
 527
 528 #  if defined (_STLP_USE_WIN32_IO)
 529   explicit basic_ifstream(_STLP_fd __id, ios_base::openmode __mod = ios_base::in) :
 530     basic_ios<_CharT, _Traits>(),  basic_istream<_CharT, _Traits>(0), _M_buf() {
 531     this->init(&_M_buf);
 532     if (!_M_buf.open(__id, __mod | ios_base::in))
 533       this->setstate(ios_base::failbit);
 534   }
 535 #  endif /* _STLP_USE_WIN32_IO */
 536 #endif
 537
 538   ~basic_ifstream() {}
 539
 540 public:                         // File and buffer operations.
 541   basic_filebuf<_CharT, _Traits>* rdbuf() const
 542     { return __CONST_CAST(_Buf*,&_M_buf); }
 543
 544   bool is_open() {
 545     return this->rdbuf()->is_open();
 546   }
 547
 548   void open(const char* __s, ios_base::openmode __mod = ios_base::in) {
 549     if (!this->rdbuf()->open(__s, __mod | ios_base::in))
 550       this->setstate(ios_base::failbit);
 551   }
 552
 553   void close() {
 554     if (!this->rdbuf()->close())
 555       this->setstate(ios_base::failbit);
 556   }
 557
 558 private:
 559   basic_filebuf<_CharT, _Traits> _M_buf;
 560 };
 561
 562
 563 //----------------------------------------------------------------------
 564 // Class basic_ofstream<>
 565
 566 template <class _CharT, class _Traits>
 567 class basic_ofstream : public basic_ostream<_CharT, _Traits> {
 568 public:                         // Types
 569   typedef _CharT                     char_type;
 570   typedef typename _Traits::int_type int_type;
 571   typedef typename _Traits::pos_type pos_type;
 572   typedef typename _Traits::off_type off_type;
 573   typedef _Traits                    traits_type;
 574
 575   typedef basic_ios<_CharT, _Traits>                _Basic_ios;
 576   typedef basic_ostream<_CharT, _Traits>            _Base;
 577   typedef basic_filebuf<_CharT, _Traits>            _Buf;
 578
 579 public:                         // Constructors, destructor.
 580   basic_ofstream() :
 581     basic_ios<_CharT, _Traits>(),
 582     basic_ostream<_CharT, _Traits>(0), _M_buf() {
 583       this->init(&_M_buf);
 584   }
 585   explicit basic_ofstream(const char* __s, ios_base::openmode __mod = ios_base::out)
 586     : basic_ios<_CharT, _Traits>(), basic_ostream<_CharT, _Traits>(0), _M_buf() {
 587     this->init(&_M_buf);
 588     if (!_M_buf.open(__s, __mod | ios_base::out))
 589       this->setstate(ios_base::failbit);
 590   }
 591
 592 #if !defined (_STLP_NO_EXTENSIONS)
 593   explicit basic_ofstream(int __id, ios_base::openmode __mod = ios_base::out)
 594     : basic_ios<_CharT, _Traits>(), basic_ostream<_CharT, _Traits>(0),
 595     _M_buf() {
 596    this->init(&_M_buf);
 597    if (!_M_buf.open(__id, __mod | ios_base::out))
 598      this->setstate(ios_base::failbit);
 599   }
 600   basic_ofstream(const char* __s, ios_base::openmode __m, long __protection) :
 601     basic_ios<_CharT, _Traits>(),  basic_ostream<_CharT, _Traits>(0), _M_buf() {
 602     this->init(&_M_buf);
 603     if (!_M_buf.open(__s, __m | ios_base::out, __protection))
 604       this->setstate(ios_base::failbit);
 605   }
 606 #  if defined (_STLP_USE_WIN32_IO)
 607   explicit basic_ofstream(_STLP_fd __id, ios_base::openmode __mod = ios_base::out)
 608     : basic_ios<_CharT, _Traits>(), basic_ostream<_CharT, _Traits>(0),
 609     _M_buf() {
 610    this->init(&_M_buf);
 611    if (!_M_buf.open(__id, __mod | ios_base::out))
 612      this->setstate(ios_base::failbit);
 613   }
 614 #  endif /* _STLP_USE_WIN32_IO */
 615 #endif
 616
 617   ~basic_ofstream() {}
 618
 619 public:                         // File and buffer operations.
 620   basic_filebuf<_CharT, _Traits>* rdbuf() const
 621     { return __CONST_CAST(_Buf*,&_M_buf); }
 622
 623   bool is_open() {
 624     return this->rdbuf()->is_open();
 625   }
 626
 627   void open(const char* __s, ios_base::openmode __mod= ios_base::out) {
 628     if (!this->rdbuf()->open(__s, __mod | ios_base::out))
 629       this->setstate(ios_base::failbit);
 630   }
 631
 632   void close() {
 633     if (!this->rdbuf()->close())
 634       this->setstate(ios_base::failbit);
 635   }
 636
 637 private:
 638   basic_filebuf<_CharT, _Traits> _M_buf;
 639 };
 640
 641
 642 //----------------------------------------------------------------------
 643 // Class basic_fstream<>
 644
 645 template <class _CharT, class _Traits>
 646 class basic_fstream : public basic_iostream<_CharT, _Traits> {
 647 public:                         // Types
 648   typedef _CharT                     char_type;
 649   typedef typename _Traits::int_type int_type;
 650   typedef typename _Traits::pos_type pos_type;
 651   typedef typename _Traits::off_type off_type;
 652   typedef _Traits                    traits_type;
 653
 654   typedef basic_ios<_CharT, _Traits>                _Basic_ios;
 655   typedef basic_iostream<_CharT, _Traits>           _Base;
 656   typedef basic_filebuf<_CharT, _Traits>            _Buf;
 657
 658 public:                         // Constructors, destructor.
 659
 660   basic_fstream()
 661     : basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
 662       this->init(&_M_buf);
 663   }
 664
 665   explicit basic_fstream(const char* __s,
 666                          ios_base::openmode __mod = ios_base::in | ios_base::out) :
 667     basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
 668       this->init(&_M_buf);
 669       if (!_M_buf.open(__s, __mod))
 670         this->setstate(ios_base::failbit);
 671   }
 672
 673 #if !defined (_STLP_NO_EXTENSIONS)
 674   explicit basic_fstream(int __id,
 675                          ios_base::openmode __mod = ios_base::in | ios_base::out) :
 676     basic_ios<_CharT, _Traits>(), basic_iostream<_CharT, _Traits>(0), _M_buf() {
 677     this->init(&_M_buf);
 678     if (!_M_buf.open(__id, __mod))
 679       this->setstate(ios_base::failbit);
 680   }
 681   basic_fstream(const char* __s, ios_base::openmode __m, long __protection) :
 682     basic_ios<_CharT, _Traits>(),  basic_iostream<_CharT, _Traits>(0), _M_buf() {
 683     this->init(&_M_buf);
 684     if (!_M_buf.open(__s, __m, __protection))
 685       this->setstate(ios_base::failbit);
 686   }
 687 #  if defined (_STLP_USE_WIN32_IO)
 688   explicit basic_fstream(_STLP_fd __id,
 689     ios_base::openmode __mod = ios_base::in | ios_base::out) :
 690     basic_ios<_CharT, _Traits>(),  basic_iostream<_CharT, _Traits>(0), _M_buf() {
 691     this->init(&_M_buf);
 692     if (!_M_buf.open(__id, __mod))
 693       this->setstate(ios_base::failbit);
 694   }
 695 #  endif /* _STLP_USE_WIN32_IO */
 696 #endif
 697   ~basic_fstream() {}
 698
 699 public:                         // File and buffer operations.
 700
 701   basic_filebuf<_CharT, _Traits>* rdbuf() const
 702     { return __CONST_CAST(_Buf*,&_M_buf); }
 703
 704   bool is_open() {
 705     return this->rdbuf()->is_open();
 706   }
 707
 708   void open(const char* __s,
 709       ios_base::openmode __mod =
 710       ios_base::in | ios_base::out) {
 711     if (!this->rdbuf()->open(__s, __mod))
 712       this->setstate(ios_base::failbit);
 713   }
 714
 715   void close() {
 716     if (!this->rdbuf()->close())
 717       this->setstate(ios_base::failbit);
 718   }
 719
 720 private:
 721   basic_filebuf<_CharT, _Traits> _M_buf;
 722
 723 #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
 724   typedef basic_fstream<_CharT, _Traits> _Self;
 725   //explicitely defined as private to avoid warnings:
 726   basic_fstream(_Self const&);
 727   _Self& operator = (_Self const&);
 728 #endif
 729 };
 730
 731 _STLP_END_NAMESPACE
 732
 733 #if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
 734 #  include <stl/_fstream.c>
 735 #endif
 736
 737 _STLP_BEGIN_NAMESPACE
 738
 739 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 740 _STLP_EXPORT_TEMPLATE_CLASS basic_ifstream<char, char_traits<char> >;
 741 _STLP_EXPORT_TEMPLATE_CLASS basic_ofstream<char, char_traits<char> >;
 742 _STLP_EXPORT_TEMPLATE_CLASS basic_fstream<char, char_traits<char> >;
 743 #  if ! defined (_STLP_NO_WCHAR_T)
 744 _STLP_EXPORT_TEMPLATE_CLASS basic_ifstream<wchar_t, char_traits<wchar_t> >;
 745 _STLP_EXPORT_TEMPLATE_CLASS basic_ofstream<wchar_t, char_traits<wchar_t> >;
 746 _STLP_EXPORT_TEMPLATE_CLASS basic_fstream<wchar_t, char_traits<wchar_t> >;
 747 #  endif
 748 #endif /* _STLP_USE_TEMPLATE_EXPORT */
 749
 750 _STLP_END_NAMESPACE
 751
 752 #endif /* _STLP_FSTREAM */
 753
 754
 755 // Local Variables:
 756 // mode:C++
 757 // End: