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