1 // File based streams -*- C++ -*- 2 3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 4 // Free Software Foundation, Inc. 5 // 6 // This file is part of the GNU ISO C++ Library. This library is free 7 // software; you can redistribute it and/or modify it under the 8 // terms of the GNU General Public License as published by the 9 // Free Software Foundation; either version 2, or (at your option) 10 // any later version. 11 12 // This library is distributed in the hope that it will be useful, 13 // but WITHOUT ANY WARRANTY; without even the implied warranty of 14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 // GNU General Public License for more details. 16 17 // You should have received a copy of the GNU General Public License along 18 // with this library; see the file COPYING. If not, write to the Free 19 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 20 // USA. 21 22 // As a special exception, you may use this file as part of a free software 23 // library without restriction. Specifically, if other files instantiate 24 // templates or use macros or inline functions from this file, or you compile 25 // this file and link it with other files to produce an executable, this 26 // file does not by itself cause the resulting executable to be covered by 27 // the GNU General Public License. This exception does not however 28 // invalidate any other reasons why the executable file might be covered by 29 // the GNU General Public License. 30 31 /** @file fstream 32 * This is a Standard C++ Library header. 33 */ 34 35 // 36 // ISO C++ 14882: 27.8 File-based streams 37 // 38 39 #ifndef _GLIBCXX_FSTREAM 40 #define _GLIBCXX_FSTREAM 1 41 42 #pragma GCC system_header 43 44 #include <istream> 45 #include <ostream> 46 #include <locale> // For codecvt 47 #include <cstdio> // For SEEK_SET, SEEK_CUR, SEEK_END, BUFSIZ 48 #include <bits/basic_file.h> 49 #include <bits/gthr.h> 50 51 _GLIBCXX_BEGIN_NAMESPACE(std) 52 53 // [27.8.1.1] template class basic_filebuf 54 /** 55 * @brief The actual work of input and output (for files). 56 * 57 * This class associates both its input and output sequence with an 58 * external disk file, and maintains a joint file position for both 59 * sequences. Many of its sematics are described in terms of similar 60 * behavior in the Standard C Library's @c FILE streams. 61 */ 62 // Requirements on traits_type, specific to this class: 63 // traits_type::pos_type must be fpos<traits_type::state_type> 64 // traits_type::off_type must be streamoff 65 // traits_type::state_type must be Assignable and DefaultConstructable, 66 // and traits_type::state_type() must be the initial state for codecvt. 67 template<typename _CharT, typename _Traits> 68 class basic_filebuf : public basic_streambuf<_CharT, _Traits> 69 { 70 public: 71 // Types: 72 typedef _CharT char_type; 73 typedef _Traits traits_type; 74 typedef typename traits_type::int_type int_type; 75 typedef typename traits_type::pos_type pos_type; 76 typedef typename traits_type::off_type off_type; 77 78 typedef basic_streambuf<char_type, traits_type> __streambuf_type; 79 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 80 typedef __basic_file<char> __file_type; 81 typedef typename traits_type::state_type __state_type; 82 typedef codecvt<char_type, char, __state_type> __codecvt_type; 83 84 friend class ios_base; // For sync_with_stdio. 85 86 protected: 87 // Data Members: 88 // MT lock inherited from libio or other low-level io library. 89 __c_lock _M_lock; 90 91 // External buffer. 92 __file_type _M_file; 93 94 /** 95 * @if maint 96 * Place to stash in || out || in | out settings for current filebuf. 97 * @endif 98 */ 99 ios_base::openmode _M_mode; 100 101 // Beginning state type for codecvt. 102 __state_type _M_state_beg; 103 104 // During output, the state that corresponds to pptr(), 105 // during input, the state that corresponds to egptr() and 106 // _M_ext_next. 107 __state_type _M_state_cur; 108 109 // Not used for output. During input, the state that corresponds 110 // to eback() and _M_ext_buf. 111 __state_type _M_state_last; 112 113 /** 114 * @if maint 115 * Pointer to the beginning of internal buffer. 116 * @endif 117 */ 118 char_type* _M_buf; 119 120 /** 121 * @if maint 122 * Actual size of internal buffer. This number is equal to the size 123 * of the put area + 1 position, reserved for the overflow char of 124 * a full area. 125 * @endif 126 */ 127 size_t _M_buf_size; 128 129 // Set iff _M_buf is allocated memory from _M_allocate_internal_buffer. 130 bool _M_buf_allocated; 131 132 /** 133 * @if maint 134 * _M_reading == false && _M_writing == false for 'uncommitted' mode; 135 * _M_reading == true for 'read' mode; 136 * _M_writing == true for 'write' mode; 137 * 138 * NB: _M_reading == true && _M_writing == true is unused. 139 * @endif 140 */ 141 bool _M_reading; 142 bool _M_writing; 143 144 //@{ 145 /** 146 * @if maint 147 * Necessary bits for putback buffer management. 148 * 149 * @note pbacks of over one character are not currently supported. 150 * @endif 151 */ 152 char_type _M_pback; 153 char_type* _M_pback_cur_save; 154 char_type* _M_pback_end_save; 155 bool _M_pback_init; 156 //@} 157 158 // Cached codecvt facet. 159 const __codecvt_type* _M_codecvt; 160 161 /** 162 * @if maint 163 * Buffer for external characters. Used for input when 164 * codecvt::always_noconv() == false. When valid, this corresponds 165 * to eback(). 166 * @endif 167 */ 168 char* _M_ext_buf; 169 170 /** 171 * @if maint 172 * Size of buffer held by _M_ext_buf. 173 * @endif 174 */ 175 streamsize _M_ext_buf_size; 176 177 /** 178 * @if maint 179 * Pointers into the buffer held by _M_ext_buf that delimit a 180 * subsequence of bytes that have been read but not yet converted. 181 * When valid, _M_ext_next corresponds to egptr(). 182 * @endif 183 */ 184 const char* _M_ext_next; 185 char* _M_ext_end; 186 187 /** 188 * @if maint 189 * Initializes pback buffers, and moves normal buffers to safety. 190 * Assumptions: 191 * _M_in_cur has already been moved back 192 * @endif 193 */ 194 void 195 _M_create_pback() 196 { 197 if (!_M_pback_init) 198 { 199 _M_pback_cur_save = this->gptr(); 200 _M_pback_end_save = this->egptr(); 201 this->setg(&_M_pback, &_M_pback, &_M_pback + 1); 202 _M_pback_init = true; 203 } 204 } 205 206 /** 207 * @if maint 208 * Deactivates pback buffer contents, and restores normal buffer. 209 * Assumptions: 210 * The pback buffer has only moved forward. 211 * @endif 212 */ 213 void 214 _M_destroy_pback() throw() 215 { 216 if (_M_pback_init) 217 { 218 // Length _M_in_cur moved in the pback buffer. 219 _M_pback_cur_save += this->gptr() != this->eback(); 220 this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); 221 _M_pback_init = false; 222 } 223 } 224 225 public: 226 // Constructors/destructor: 227 /** 228 * @brief Does not open any files. 229 * 230 * The default constructor initializes the parent class using its 231 * own default ctor. 232 */ 233 basic_filebuf(); 234 235 /** 236 * @brief The destructor closes the file first. 237 */ 238 virtual 239 ~basic_filebuf() 240 { this->close(); } 241 242 // Members: 243 /** 244 * @brief Returns true if the external file is open. 245 */ 246 bool 247 is_open() const throw() 248 { return _M_file.is_open(); } 249 250 /** 251 * @brief Opens an external file. 252 * @param s The name of the file. 253 * @param mode The open mode flags. 254 * @return @c this on success, NULL on failure 255 * 256 * If a file is already open, this function immediately fails. 257 * Otherwise it tries to open the file named @a s using the flags 258 * given in @a mode. 259 * 260 * [Table 92 gives the relation between openmode combinations and the 261 * equivalent fopen() flags, but the table has not been copied yet.] 262 */ 263 __filebuf_type* 264 open(const char* __s, ios_base::openmode __mode); 265 266 /** 267 * @brief Closes the currently associated file. 268 * @return @c this on success, NULL on failure 269 * 270 * If no file is currently open, this function immediately fails. 271 * 272 * If a "put buffer area" exists, @c overflow(eof) is called to flush 273 * all the characters. The file is then closed. 274 * 275 * If any operations fail, this function also fails. 276 */ 277 __filebuf_type* 278 close() throw(); 279 280 protected: 281 void 282 _M_allocate_internal_buffer(); 283 284 void 285 _M_destroy_internal_buffer() throw(); 286 287 // [27.8.1.4] overridden virtual functions 288 virtual streamsize 289 showmanyc(); 290 291 // Stroustrup, 1998, p. 628 292 // underflow() and uflow() functions are called to get the next 293 // charater from the real input source when the buffer is empty. 294 // Buffered input uses underflow() 295 296 virtual int_type 297 underflow(); 298 299 virtual int_type 300 pbackfail(int_type __c = _Traits::eof()); 301 302 // Stroustrup, 1998, p 648 303 // The overflow() function is called to transfer characters to the 304 // real output destination when the buffer is full. A call to 305 // overflow(c) outputs the contents of the buffer plus the 306 // character c. 307 // 27.5.2.4.5 308 // Consume some sequence of the characters in the pending sequence. 309 virtual int_type 310 overflow(int_type __c = _Traits::eof()); 311 312 // Convert internal byte sequence to external, char-based 313 // sequence via codecvt. 314 bool 315 _M_convert_to_external(char_type*, streamsize); 316 317 /** 318 * @brief Manipulates the buffer. 319 * @param s Pointer to a buffer area. 320 * @param n Size of @a s. 321 * @return @c this 322 * 323 * If no file has been opened, and both @a s and @a n are zero, then 324 * the stream becomes unbuffered. Otherwise, @c s is used as a 325 * buffer; see 326 * http://gcc.gnu.org/onlinedocs/libstdc++/27_io/howto.html#2 327 * for more. 328 */ 329 virtual __streambuf_type* 330 setbuf(char_type* __s, streamsize __n); 331 332 virtual pos_type 333 seekoff(off_type __off, ios_base::seekdir __way, 334 ios_base::openmode __mode = ios_base::in | ios_base::out); 335 336 virtual pos_type 337 seekpos(pos_type __pos, 338 ios_base::openmode __mode = ios_base::in | ios_base::out); 339 340 // Common code for seekoff and seekpos 341 pos_type 342 _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); 343 344 virtual int 345 sync(); 346 347 virtual void 348 imbue(const locale& __loc); 349 350 virtual streamsize 351 xsgetn(char_type* __s, streamsize __n); 352 353 virtual streamsize 354 xsputn(const char_type* __s, streamsize __n); 355 356 // Flushes output buffer, then writes unshift sequence. 357 bool 358 _M_terminate_output(); 359 360 /** 361 * @if maint 362 * This function sets the pointers of the internal buffer, both get 363 * and put areas. Typically: 364 * 365 * __off == egptr() - eback() upon underflow/uflow ('read' mode); 366 * __off == 0 upon overflow ('write' mode); 367 * __off == -1 upon open, setbuf, seekoff/pos ('uncommitted' mode). 368 * 369 * NB: epptr() - pbase() == _M_buf_size - 1, since _M_buf_size 370 * reflects the actual allocated memory and the last cell is reserved 371 * for the overflow char of a full put area. 372 * @endif 373 */ 374 void 375 _M_set_buffer(streamsize __off) 376 { 377 const bool __testin = _M_mode & ios_base::in; 378 const bool __testout = _M_mode & ios_base::out; 379 380 if (__testin && __off > 0) 381 this->setg(_M_buf, _M_buf, _M_buf + __off); 382 else 383 this->setg(_M_buf, _M_buf, _M_buf); 384 385 if (__testout && __off == 0 && _M_buf_size > 1 ) 386 this->setp(_M_buf, _M_buf + _M_buf_size - 1); 387 else 388 this->setp(NULL, NULL); 389 } 390 }; 391 392 // [27.8.1.5] Template class basic_ifstream 393 /** 394 * @brief Controlling input for files. 395 * 396 * This class supports reading from named files, using the inherited 397 * functions from std::basic_istream. To control the associated 398 * sequence, an instance of std::basic_filebuf is used, which this page 399 * refers to as @c sb. 400 */ 401 template<typename _CharT, typename _Traits> 402 class basic_ifstream : public basic_istream<_CharT, _Traits> 403 { 404 public: 405 // Types: 406 typedef _CharT char_type; 407 typedef _Traits traits_type; 408 typedef typename traits_type::int_type int_type; 409 typedef typename traits_type::pos_type pos_type; 410 typedef typename traits_type::off_type off_type; 411 412 // Non-standard types: 413 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 414 typedef basic_istream<char_type, traits_type> __istream_type; 415 416 private: 417 __filebuf_type _M_filebuf; 418 419 public: 420 // Constructors/Destructors: 421 /** 422 * @brief Default constructor. 423 * 424 * Initializes @c sb using its default constructor, and passes 425 * @c &sb to the base class initializer. Does not open any files 426 * (you haven't given it a filename to open). 427 */ 428 basic_ifstream() : __istream_type(), _M_filebuf() 429 { this->init(&_M_filebuf); } 430 431 /** 432 * @brief Create an input file stream. 433 * @param s Null terminated string specifying the filename. 434 * @param mode Open file in specified mode (see std::ios_base). 435 * 436 * @c ios_base::in is automatically included in @a mode. 437 * 438 * Tip: When using std::string to hold the filename, you must use 439 * .c_str() before passing it to this constructor. 440 */ 441 explicit 442 basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) 443 : __istream_type(), _M_filebuf() 444 { 445 this->init(&_M_filebuf); 446 this->open(__s, __mode); 447 } 448 449 /** 450 * @brief The destructor does nothing. 451 * 452 * The file is closed by the filebuf object, not the formatting 453 * stream. 454 */ 455 ~basic_ifstream() 456 { } 457 458 // Members: 459 /** 460 * @brief Accessing the underlying buffer. 461 * @return The current basic_filebuf buffer. 462 * 463 * This hides both signatures of std::basic_ios::rdbuf(). 464 */ 465 __filebuf_type* 466 rdbuf() const 467 { return const_cast<__filebuf_type*>(&_M_filebuf); } 468 469 /** 470 * @brief Wrapper to test for an open file. 471 * @return @c rdbuf()->is_open() 472 */ 473 bool 474 is_open() 475 { return _M_filebuf.is_open(); } 476 477 // _GLIBCXX_RESOLVE_LIB_DEFECTS 478 // 365. Lack of const-qualification in clause 27 479 bool 480 is_open() const 481 { return _M_filebuf.is_open(); } 482 483 /** 484 * @brief Opens an external file. 485 * @param s The name of the file. 486 * @param mode The open mode flags. 487 * 488 * Calls @c std::basic_filebuf::open(s,mode|in). If that function 489 * fails, @c failbit is set in the stream's error state. 490 * 491 * Tip: When using std::string to hold the filename, you must use 492 * .c_str() before passing it to this constructor. 493 */ 494 void 495 open(const char* __s, ios_base::openmode __mode = ios_base::in) 496 { 497 if (!_M_filebuf.open(__s, __mode | ios_base::in)) 498 this->setstate(ios_base::failbit); 499 else 500 // _GLIBCXX_RESOLVE_LIB_DEFECTS 501 // 409. Closing an fstream should clear error state 502 this->clear(); 503 } 504 505 /** 506 * @brief Close the file. 507 * 508 * Calls @c std::basic_filebuf::close(). If that function 509 * fails, @c failbit is set in the stream's error state. 510 */ 511 void 512 close() 513 { 514 if (!_M_filebuf.close()) 515 this->setstate(ios_base::failbit); 516 } 517 }; 518 519 520 // [27.8.1.8] Template class basic_ofstream 521 /** 522 * @brief Controlling output for files. 523 * 524 * This class supports reading from named files, using the inherited 525 * functions from std::basic_ostream. To control the associated 526 * sequence, an instance of std::basic_filebuf is used, which this page 527 * refers to as @c sb. 528 */ 529 template<typename _CharT, typename _Traits> 530 class basic_ofstream : public basic_ostream<_CharT,_Traits> 531 { 532 public: 533 // Types: 534 typedef _CharT char_type; 535 typedef _Traits traits_type; 536 typedef typename traits_type::int_type int_type; 537 typedef typename traits_type::pos_type pos_type; 538 typedef typename traits_type::off_type off_type; 539 540 // Non-standard types: 541 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 542 typedef basic_ostream<char_type, traits_type> __ostream_type; 543 544 private: 545 __filebuf_type _M_filebuf; 546 547 public: 548 // Constructors: 549 /** 550 * @brief Default constructor. 551 * 552 * Initializes @c sb using its default constructor, and passes 553 * @c &sb to the base class initializer. Does not open any files 554 * (you haven't given it a filename to open). 555 */ 556 basic_ofstream(): __ostream_type(), _M_filebuf() 557 { this->init(&_M_filebuf); } 558 559 /** 560 * @brief Create an output file stream. 561 * @param s Null terminated string specifying the filename. 562 * @param mode Open file in specified mode (see std::ios_base). 563 * 564 * @c ios_base::out|ios_base::trunc is automatically included in 565 * @a mode. 566 * 567 * Tip: When using std::string to hold the filename, you must use 568 * .c_str() before passing it to this constructor. 569 */ 570 explicit 571 basic_ofstream(const char* __s, 572 ios_base::openmode __mode = ios_base::out|ios_base::trunc) 573 : __ostream_type(), _M_filebuf() 574 { 575 this->init(&_M_filebuf); 576 this->open(__s, __mode); 577 } 578 579 /** 580 * @brief The destructor does nothing. 581 * 582 * The file is closed by the filebuf object, not the formatting 583 * stream. 584 */ 585 ~basic_ofstream() 586 { } 587 588 // Members: 589 /** 590 * @brief Accessing the underlying buffer. 591 * @return The current basic_filebuf buffer. 592 * 593 * This hides both signatures of std::basic_ios::rdbuf(). 594 */ 595 __filebuf_type* 596 rdbuf() const 597 { return const_cast<__filebuf_type*>(&_M_filebuf); } 598 599 /** 600 * @brief Wrapper to test for an open file. 601 * @return @c rdbuf()->is_open() 602 */ 603 bool 604 is_open() 605 { return _M_filebuf.is_open(); } 606 607 // _GLIBCXX_RESOLVE_LIB_DEFECTS 608 // 365. Lack of const-qualification in clause 27 609 bool 610 is_open() const 611 { return _M_filebuf.is_open(); } 612 613 /** 614 * @brief Opens an external file. 615 * @param s The name of the file. 616 * @param mode The open mode flags. 617 * 618 * Calls @c std::basic_filebuf::open(s,mode|out|trunc). If that 619 * function fails, @c failbit is set in the stream's error state. 620 * 621 * Tip: When using std::string to hold the filename, you must use 622 * .c_str() before passing it to this constructor. 623 */ 624 void 625 open(const char* __s, 626 ios_base::openmode __mode = ios_base::out | ios_base::trunc) 627 { 628 if (!_M_filebuf.open(__s, __mode | ios_base::out)) 629 this->setstate(ios_base::failbit); 630 else 631 // _GLIBCXX_RESOLVE_LIB_DEFECTS 632 // 409. Closing an fstream should clear error state 633 this->clear(); 634 } 635 636 /** 637 * @brief Close the file. 638 * 639 * Calls @c std::basic_filebuf::close(). If that function 640 * fails, @c failbit is set in the stream's error state. 641 */ 642 void 643 close() 644 { 645 if (!_M_filebuf.close()) 646 this->setstate(ios_base::failbit); 647 } 648 }; 649 650 651 // [27.8.1.11] Template class basic_fstream 652 /** 653 * @brief Controlling intput and output for files. 654 * 655 * This class supports reading from and writing to named files, using 656 * the inherited functions from std::basic_iostream. To control the 657 * associated sequence, an instance of std::basic_filebuf is used, which 658 * this page refers to as @c sb. 659 */ 660 template<typename _CharT, typename _Traits> 661 class basic_fstream : public basic_iostream<_CharT, _Traits> 662 { 663 public: 664 // Types: 665 typedef _CharT char_type; 666 typedef _Traits traits_type; 667 typedef typename traits_type::int_type int_type; 668 typedef typename traits_type::pos_type pos_type; 669 typedef typename traits_type::off_type off_type; 670 671 // Non-standard types: 672 typedef basic_filebuf<char_type, traits_type> __filebuf_type; 673 typedef basic_ios<char_type, traits_type> __ios_type; 674 typedef basic_iostream<char_type, traits_type> __iostream_type; 675 676 private: 677 __filebuf_type _M_filebuf; 678 679 public: 680 // Constructors/destructor: 681 /** 682 * @brief Default constructor. 683 * 684 * Initializes @c sb using its default constructor, and passes 685 * @c &sb to the base class initializer. Does not open any files 686 * (you haven't given it a filename to open). 687 */ 688 basic_fstream() 689 : __iostream_type(), _M_filebuf() 690 { this->init(&_M_filebuf); } 691 692 /** 693 * @brief Create an input/output file stream. 694 * @param s Null terminated string specifying the filename. 695 * @param mode Open file in specified mode (see std::ios_base). 696 * 697 * Tip: When using std::string to hold the filename, you must use 698 * .c_str() before passing it to this constructor. 699 */ 700 explicit 701 basic_fstream(const char* __s, 702 ios_base::openmode __mode = ios_base::in | ios_base::out) 703 : __iostream_type(NULL), _M_filebuf() 704 { 705 this->init(&_M_filebuf); 706 this->open(__s, __mode); 707 } 708 709 /** 710 * @brief The destructor does nothing. 711 * 712 * The file is closed by the filebuf object, not the formatting 713 * stream. 714 */ 715 ~basic_fstream() 716 { } 717 718 // Members: 719 /** 720 * @brief Accessing the underlying buffer. 721 * @return The current basic_filebuf buffer. 722 * 723 * This hides both signatures of std::basic_ios::rdbuf(). 724 */ 725 __filebuf_type* 726 rdbuf() const 727 { return const_cast<__filebuf_type*>(&_M_filebuf); } 728 729 /** 730 * @brief Wrapper to test for an open file. 731 * @return @c rdbuf()->is_open() 732 */ 733 bool 734 is_open() 735 { return _M_filebuf.is_open(); } 736 737 // _GLIBCXX_RESOLVE_LIB_DEFECTS 738 // 365. Lack of const-qualification in clause 27 739 bool 740 is_open() const 741 { return _M_filebuf.is_open(); } 742 743 /** 744 * @brief Opens an external file. 745 * @param s The name of the file. 746 * @param mode The open mode flags. 747 * 748 * Calls @c std::basic_filebuf::open(s,mode). If that 749 * function fails, @c failbit is set in the stream's error state. 750 * 751 * Tip: When using std::string to hold the filename, you must use 752 * .c_str() before passing it to this constructor. 753 */ 754 void 755 open(const char* __s, 756 ios_base::openmode __mode = ios_base::in | ios_base::out) 757 { 758 if (!_M_filebuf.open(__s, __mode)) 759 this->setstate(ios_base::failbit); 760 else 761 // _GLIBCXX_RESOLVE_LIB_DEFECTS 762 // 409. Closing an fstream should clear error state 763 this->clear(); 764 } 765 766 /** 767 * @brief Close the file. 768 * 769 * Calls @c std::basic_filebuf::close(). If that function 770 * fails, @c failbit is set in the stream's error state. 771 */ 772 void 773 close() 774 { 775 if (!_M_filebuf.close()) 776 this->setstate(ios_base::failbit); 777 } 778 }; 779 780 _GLIBCXX_END_NAMESPACE 781 782 #ifndef _GLIBCXX_EXPORT_TEMPLATE 783 # include <bits/fstream.tcc> 784 #endif 785 786 #endif /* _GLIBCXX_FSTREAM */ 787