1// File based streams -*- C++ -*- 2 3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 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.tcc 32 * This is an internal header file, included by other library headers. 33 * You should not attempt to use it directly. 34 */ 35 36// 37// ISO C++ 14882: 27.8 File-based streams 38// 39 40#ifndef _FSTREAM_TCC 41#define _FSTREAM_TCC 1 42 43#pragma GCC system_header 44 45namespace std 46{ 47 template<typename _CharT, typename _Traits> 48 void 49 basic_filebuf<_CharT, _Traits>:: 50 _M_allocate_internal_buffer() 51 { 52 // Allocate internal buffer only if one doesn't already exist 53 // (either allocated or provided by the user via setbuf). 54 if (!_M_buf_allocated && !_M_buf) 55 { 56 _M_buf = new char_type[_M_buf_size]; 57 _M_buf_allocated = true; 58 } 59 } 60 61 template<typename _CharT, typename _Traits> 62 void 63 basic_filebuf<_CharT, _Traits>:: 64 _M_destroy_internal_buffer() throw() 65 { 66 if (_M_buf_allocated) 67 { 68 delete [] _M_buf; 69 _M_buf = NULL; 70 _M_buf_allocated = false; 71 } 72 delete [] _M_ext_buf; 73 _M_ext_buf = NULL; 74 _M_ext_buf_size = 0; 75 _M_ext_next = NULL; 76 _M_ext_end = NULL; 77 } 78 79 template<typename _CharT, typename _Traits> 80 basic_filebuf<_CharT, _Traits>:: 81 basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock), 82 _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(), 83 _M_state_last(), _M_buf(NULL), _M_buf_size(BUFSIZ), 84 _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), 85 _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false), 86 _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0), 87 _M_ext_end(0) 88 { 89 if (has_facet<__codecvt_type>(this->_M_buf_locale)) 90 _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale); 91 } 92 93 template<typename _CharT, typename _Traits> 94 typename basic_filebuf<_CharT, _Traits>::__filebuf_type* 95 basic_filebuf<_CharT, _Traits>:: 96 open(const char* __s, ios_base::openmode __mode) 97 { 98 __filebuf_type *__ret = NULL; 99 if (!this->is_open()) 100 { 101 _M_file.open(__s, __mode); 102 if (this->is_open()) 103 { 104 _M_allocate_internal_buffer(); 105 _M_mode = __mode; 106 107 // Setup initial buffer to 'uncommitted' mode. 108 _M_reading = false; 109 _M_writing = false; 110 _M_set_buffer(-1); 111 112 // Reset to initial state. 113 _M_state_last = _M_state_cur = _M_state_beg; 114 115 // 27.8.1.3,4 116 if ((__mode & ios_base::ate) 117 && this->seekoff(0, ios_base::end, __mode) 118 == pos_type(off_type(-1))) 119 this->close(); 120 else 121 __ret = this; 122 } 123 } 124 return __ret; 125 } 126 127 template<typename _CharT, typename _Traits> 128 typename basic_filebuf<_CharT, _Traits>::__filebuf_type* 129 basic_filebuf<_CharT, _Traits>:: 130 close() throw() 131 { 132 __filebuf_type* __ret = NULL; 133 if (this->is_open()) 134 { 135 bool __testfail = false; 136 try 137 { 138 if (!_M_terminate_output()) 139 __testfail = true; 140 } 141 catch(...) 142 { __testfail = true; } 143 144 // NB: Do this here so that re-opened filebufs will be cool... 145 _M_mode = ios_base::openmode(0); 146 _M_pback_init = false; 147 _M_destroy_internal_buffer(); 148 _M_reading = false; 149 _M_writing = false; 150 _M_set_buffer(-1); 151 _M_state_last = _M_state_cur = _M_state_beg; 152 153 if (!_M_file.close()) 154 __testfail = true; 155 156 if (!__testfail) 157 __ret = this; 158 } 159 return __ret; 160 } 161 162 template<typename _CharT, typename _Traits> 163 streamsize 164 basic_filebuf<_CharT, _Traits>:: 165 showmanyc() 166 { 167 streamsize __ret = -1; 168 const bool __testin = _M_mode & ios_base::in; 169 if (__testin && this->is_open()) 170 { 171 // For a stateful encoding (-1) the pending sequence might be just 172 // shift and unshift prefixes with no actual character. 173 __ret = this->egptr() - this->gptr(); 174 175#if _GLIBCXX_HAVE_DOS_BASED_FILESYSTEM 176 // About this workaround, see libstdc++/20806. 177 const bool __testbinary = _M_mode & ios_base::binary; 178 if (__check_facet(_M_codecvt).encoding() >= 0 179 && __testbinary) 180#else 181 if (__check_facet(_M_codecvt).encoding() >= 0) 182#endif 183 __ret += _M_file.showmanyc() / _M_codecvt->max_length(); 184 } 185 return __ret; 186 } 187 188 template<typename _CharT, typename _Traits> 189 typename basic_filebuf<_CharT, _Traits>::int_type 190 basic_filebuf<_CharT, _Traits>:: 191 underflow() 192 { 193 int_type __ret = traits_type::eof(); 194 const bool __testin = _M_mode & ios_base::in; 195 if (__testin && !_M_writing) 196 { 197 // Check for pback madness, and if so swich back to the 198 // normal buffers and jet outta here before expensive 199 // fileops happen... 200 _M_destroy_pback(); 201 202 if (this->gptr() < this->egptr()) 203 return traits_type::to_int_type(*this->gptr()); 204 205 // Get and convert input sequence. 206 const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; 207 208 // Will be set to true if ::read() returns 0 indicating EOF. 209 bool __got_eof = false; 210 // Number of internal characters produced. 211 streamsize __ilen = 0; 212 codecvt_base::result __r = codecvt_base::ok; 213 if (__check_facet(_M_codecvt).always_noconv()) 214 { 215 __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()), 216 __buflen); 217 if (__ilen == 0) 218 __got_eof = true; 219 } 220 else 221 { 222 // Worst-case number of external bytes. 223 // XXX Not done encoding() == -1. 224 const int __enc = _M_codecvt->encoding(); 225 streamsize __blen; // Minimum buffer size. 226 streamsize __rlen; // Number of chars to read. 227 if (__enc > 0) 228 __blen = __rlen = __buflen * __enc; 229 else 230 { 231 __blen = __buflen + _M_codecvt->max_length() - 1; 232 __rlen = __buflen; 233 } 234 const streamsize __remainder = _M_ext_end - _M_ext_next; 235 __rlen = __rlen > __remainder ? __rlen - __remainder : 0; 236 237 // An imbue in 'read' mode implies first converting the external 238 // chars already present. 239 if (_M_reading && this->egptr() == this->eback() && __remainder) 240 __rlen = 0; 241 242 // Allocate buffer if necessary and move unconverted 243 // bytes to front. 244 if (_M_ext_buf_size < __blen) 245 { 246 char* __buf = new char[__blen]; 247 if (__remainder) 248 std::memcpy(__buf, _M_ext_next, __remainder); 249 250 delete [] _M_ext_buf; 251 _M_ext_buf = __buf; 252 _M_ext_buf_size = __blen; 253 } 254 else if (__remainder) 255 std::memmove(_M_ext_buf, _M_ext_next, __remainder); 256 257 _M_ext_next = _M_ext_buf; 258 _M_ext_end = _M_ext_buf + __remainder; 259 _M_state_last = _M_state_cur; 260 261 do 262 { 263 if (__rlen > 0) 264 { 265 // Sanity check! 266 // This may fail if the return value of 267 // codecvt::max_length() is bogus. 268 if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size) 269 { 270 __throw_ios_failure(__N("basic_filebuf::underflow " 271 "codecvt::max_length() " 272 "is not valid")); 273 } 274 streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen); 275 if (__elen == 0) 276 __got_eof = true; 277 else if (__elen == -1) 278 break; 279 _M_ext_end += __elen; 280 } 281 282 char_type* __iend; 283 __r = _M_codecvt->in(_M_state_cur, _M_ext_next, 284 _M_ext_end, _M_ext_next, this->eback(), 285 this->eback() + __buflen, __iend); 286 if (__r == codecvt_base::noconv) 287 { 288 size_t __avail = _M_ext_end - _M_ext_buf; 289 __ilen = std::min(__avail, __buflen); 290 traits_type::copy(this->eback(), 291 reinterpret_cast<char_type*>(_M_ext_buf), __ilen); 292 _M_ext_next = _M_ext_buf + __ilen; 293 } 294 else 295 __ilen = __iend - this->eback(); 296 297 // _M_codecvt->in may return error while __ilen > 0: this is 298 // ok, and actually occurs in case of mixed encodings (e.g., 299 // XML files). 300 if (__r == codecvt_base::error) 301 break; 302 303 __rlen = 1; 304 } 305 while (__ilen == 0 && !__got_eof); 306 } 307 308 if (__ilen > 0) 309 { 310 _M_set_buffer(__ilen); 311 _M_reading = true; 312 __ret = traits_type::to_int_type(*this->gptr()); 313 } 314 else if (__got_eof) 315 { 316 // If the actual end of file is reached, set 'uncommitted' 317 // mode, thus allowing an immediate write without an 318 // intervening seek. 319 _M_set_buffer(-1); 320 _M_reading = false; 321 // However, reaching it while looping on partial means that 322 // the file has got an incomplete character. 323 if (__r == codecvt_base::partial) 324 __throw_ios_failure(__N("basic_filebuf::underflow " 325 "incomplete character in file")); 326 } 327 else if (__r == codecvt_base::error) 328 __throw_ios_failure(__N("basic_filebuf::underflow " 329 "invalid byte sequence in file")); 330 else 331 __throw_ios_failure(__N("basic_filebuf::underflow " 332 "error reading the file")); 333 } 334 return __ret; 335 } 336 337 template<typename _CharT, typename _Traits> 338 typename basic_filebuf<_CharT, _Traits>::int_type 339 basic_filebuf<_CharT, _Traits>:: 340 pbackfail(int_type __i) 341 { 342 int_type __ret = traits_type::eof(); 343 const bool __testin = _M_mode & ios_base::in; 344 if (__testin && !_M_writing) 345 { 346 // Remember whether the pback buffer is active, otherwise below 347 // we may try to store in it a second char (libstdc++/9761). 348 const bool __testpb = _M_pback_init; 349 const bool __testeof = traits_type::eq_int_type(__i, __ret); 350 int_type __tmp; 351 if (this->eback() < this->gptr()) 352 { 353 this->gbump(-1); 354 __tmp = traits_type::to_int_type(*this->gptr()); 355 } 356 else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1))) 357 { 358 __tmp = this->underflow(); 359 if (traits_type::eq_int_type(__tmp, __ret)) 360 return __ret; 361 } 362 else 363 { 364 // At the beginning of the buffer, need to make a 365 // putback position available. But the seek may fail 366 // (f.i., at the beginning of a file, see 367 // libstdc++/9439) and in that case we return 368 // traits_type::eof(). 369 return __ret; 370 } 371 372 // Try to put back __i into input sequence in one of three ways. 373 // Order these tests done in is unspecified by the standard. 374 if (!__testeof && traits_type::eq_int_type(__i, __tmp)) 375 __ret = __i; 376 else if (__testeof) 377 __ret = traits_type::not_eof(__i); 378 else if (!__testpb) 379 { 380 _M_create_pback(); 381 _M_reading = true; 382 *this->gptr() = traits_type::to_char_type(__i); 383 __ret = __i; 384 } 385 } 386 return __ret; 387 } 388 389 template<typename _CharT, typename _Traits> 390 typename basic_filebuf<_CharT, _Traits>::int_type 391 basic_filebuf<_CharT, _Traits>:: 392 overflow(int_type __c) 393 { 394 int_type __ret = traits_type::eof(); 395 const bool __testeof = traits_type::eq_int_type(__c, __ret); 396 const bool __testout = _M_mode & ios_base::out; 397 if (__testout && !_M_reading) 398 { 399 if (this->pbase() < this->pptr()) 400 { 401 // If appropriate, append the overflow char. 402 if (!__testeof) 403 { 404 *this->pptr() = traits_type::to_char_type(__c); 405 this->pbump(1); 406 } 407 408 // Convert pending sequence to external representation, 409 // and output. 410 if (_M_convert_to_external(this->pbase(), 411 this->pptr() - this->pbase())) 412 { 413 _M_set_buffer(0); 414 __ret = traits_type::not_eof(__c); 415 } 416 } 417 else if (_M_buf_size > 1) 418 { 419 // Overflow in 'uncommitted' mode: set _M_writing, set 420 // the buffer to the initial 'write' mode, and put __c 421 // into the buffer. 422 _M_set_buffer(0); 423 _M_writing = true; 424 if (!__testeof) 425 { 426 *this->pptr() = traits_type::to_char_type(__c); 427 this->pbump(1); 428 } 429 __ret = traits_type::not_eof(__c); 430 } 431 else 432 { 433 // Unbuffered. 434 char_type __conv = traits_type::to_char_type(__c); 435 if (__testeof || _M_convert_to_external(&__conv, 1)) 436 { 437 _M_writing = true; 438 __ret = traits_type::not_eof(__c); 439 } 440 } 441 } 442 return __ret; 443 } 444 445 template<typename _CharT, typename _Traits> 446 bool 447 basic_filebuf<_CharT, _Traits>:: 448 _M_convert_to_external(_CharT* __ibuf, streamsize __ilen) 449 { 450 // Sizes of external and pending output. 451 streamsize __elen; 452 streamsize __plen; 453 if (__check_facet(_M_codecvt).always_noconv()) 454 { 455 __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen); 456 __plen = __ilen; 457 } 458 else 459 { 460 // Worst-case number of external bytes needed. 461 // XXX Not done encoding() == -1. 462 streamsize __blen = __ilen * _M_codecvt->max_length(); 463 char* __buf = static_cast<char*>(__builtin_alloca(__blen)); 464 465 char* __bend; 466 const char_type* __iend; 467 codecvt_base::result __r; 468 __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen, 469 __iend, __buf, __buf + __blen, __bend); 470 471 if (__r == codecvt_base::ok || __r == codecvt_base::partial) 472 __blen = __bend - __buf; 473 else if (__r == codecvt_base::noconv) 474 { 475 // Same as the always_noconv case above. 476 __buf = reinterpret_cast<char*>(__ibuf); 477 __blen = __ilen; 478 } 479 else 480 __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external " 481 "conversion error")); 482 483 __elen = _M_file.xsputn(__buf, __blen); 484 __plen = __blen; 485 486 // Try once more for partial conversions. 487 if (__r == codecvt_base::partial && __elen == __plen) 488 { 489 const char_type* __iresume = __iend; 490 streamsize __rlen = this->pptr() - __iend; 491 __r = _M_codecvt->out(_M_state_cur, __iresume, 492 __iresume + __rlen, __iend, __buf, 493 __buf + __blen, __bend); 494 if (__r != codecvt_base::error) 495 { 496 __rlen = __bend - __buf; 497 __elen = _M_file.xsputn(__buf, __rlen); 498 __plen = __rlen; 499 } 500 else 501 __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external " 502 "conversion error")); 503 } 504 } 505 return __elen == __plen; 506 } 507 508 template<typename _CharT, typename _Traits> 509 streamsize 510 basic_filebuf<_CharT, _Traits>:: 511 xsgetn(_CharT* __s, streamsize __n) 512 { 513 // Clear out pback buffer before going on to the real deal... 514 streamsize __ret = 0; 515 if (_M_pback_init) 516 { 517 if (__n > 0 && this->gptr() == this->eback()) 518 { 519 *__s++ = *this->gptr(); 520 this->gbump(1); 521 __ret = 1; 522 --__n; 523 } 524 _M_destroy_pback(); 525 } 526 527 // Optimization in the always_noconv() case, to be generalized in the 528 // future: when __n > __buflen we read directly instead of using the 529 // buffer repeatedly. 530 const bool __testin = _M_mode & ios_base::in; 531 const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; 532 533 if (__n > __buflen && __check_facet(_M_codecvt).always_noconv() 534 && __testin && !_M_writing) 535 { 536 // First, copy the chars already present in the buffer. 537 const streamsize __avail = this->egptr() - this->gptr(); 538 if (__avail != 0) 539 { 540 if (__avail == 1) 541 *__s = *this->gptr(); 542 else 543 traits_type::copy(__s, this->gptr(), __avail); 544 __s += __avail; 545 this->gbump(__avail); 546 __ret += __avail; 547 __n -= __avail; 548 } 549 550 // Need to loop in case of short reads (relatively common 551 // with pipes). 552 streamsize __len; 553 for (;;) 554 { 555 __len = _M_file.xsgetn(reinterpret_cast<char*>(__s), 556 __n); 557 if (__len == -1) 558 __throw_ios_failure(__N("basic_filebuf::xsgetn " 559 "error reading the file")); 560 if (__len == 0) 561 break; 562 563 __n -= __len; 564 __ret += __len; 565 if (__n == 0) 566 break; 567 568 __s += __len; 569 } 570 571 if (__n == 0) 572 { 573 _M_set_buffer(0); 574 _M_reading = true; 575 } 576 else if (__len == 0) 577 { 578 // If end of file is reached, set 'uncommitted' 579 // mode, thus allowing an immediate write without 580 // an intervening seek. 581 _M_set_buffer(-1); 582 _M_reading = false; 583 } 584 } 585 else 586 __ret += __streambuf_type::xsgetn(__s, __n); 587 588 return __ret; 589 } 590 591 template<typename _CharT, typename _Traits> 592 streamsize 593 basic_filebuf<_CharT, _Traits>:: 594 xsputn(const _CharT* __s, streamsize __n) 595 { 596 // Optimization in the always_noconv() case, to be generalized in the 597 // future: when __n is sufficiently large we write directly instead of 598 // using the buffer. 599 streamsize __ret = 0; 600 const bool __testout = _M_mode & ios_base::out; 601 if (__check_facet(_M_codecvt).always_noconv() 602 && __testout && !_M_reading) 603 { 604 // Measurement would reveal the best choice. 605 const streamsize __chunk = 1ul << 10; 606 streamsize __bufavail = this->epptr() - this->pptr(); 607 608 // Don't mistake 'uncommitted' mode buffered with unbuffered. 609 if (!_M_writing && _M_buf_size > 1) 610 __bufavail = _M_buf_size - 1; 611 612 const streamsize __limit = std::min(__chunk, __bufavail); 613 if (__n >= __limit) 614 { 615 const streamsize __buffill = this->pptr() - this->pbase(); 616 const char* __buf = reinterpret_cast<const char*>(this->pbase()); 617 __ret = _M_file.xsputn_2(__buf, __buffill, 618 reinterpret_cast<const char*>(__s), 619 __n); 620 if (__ret == __buffill + __n) 621 { 622 _M_set_buffer(0); 623 _M_writing = true; 624 } 625 if (__ret > __buffill) 626 __ret -= __buffill; 627 else 628 __ret = 0; 629 } 630 else 631 __ret = __streambuf_type::xsputn(__s, __n); 632 } 633 else 634 __ret = __streambuf_type::xsputn(__s, __n); 635 return __ret; 636 } 637 638 template<typename _CharT, typename _Traits> 639 typename basic_filebuf<_CharT, _Traits>::__streambuf_type* 640 basic_filebuf<_CharT, _Traits>:: 641 setbuf(char_type* __s, streamsize __n) 642 { 643 if (!this->is_open()) 644 if (__s == 0 && __n == 0) 645 _M_buf_size = 1; 646 else if (__s && __n > 0) 647 { 648 // This is implementation-defined behavior, and assumes that 649 // an external char_type array of length __n exists and has 650 // been pre-allocated. If this is not the case, things will 651 // quickly blow up. When __n > 1, __n - 1 positions will be 652 // used for the get area, __n - 1 for the put area and 1 653 // position to host the overflow char of a full put area. 654 // When __n == 1, 1 position will be used for the get area 655 // and 0 for the put area, as in the unbuffered case above. 656 _M_buf = __s; 657 _M_buf_size = __n; 658 } 659 return this; 660 } 661 662 663 // According to 27.8.1.4 p11 - 13, seekoff should ignore the last 664 // argument (of type openmode). 665 template<typename _CharT, typename _Traits> 666 typename basic_filebuf<_CharT, _Traits>::pos_type 667 basic_filebuf<_CharT, _Traits>:: 668 seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode) 669 { 670 int __width = 0; 671 if (_M_codecvt) 672 __width = _M_codecvt->encoding(); 673 if (__width < 0) 674 __width = 0; 675 676 pos_type __ret = pos_type(off_type(-1)); 677 const bool __testfail = __off != 0 && __width <= 0; 678 if (this->is_open() && !__testfail) 679 { 680 // Ditch any pback buffers to avoid confusion. 681 _M_destroy_pback(); 682 683 // Correct state at destination. Note that this is the correct 684 // state for the current position during output, because 685 // codecvt::unshift() returns the state to the initial state. 686 // This is also the correct state at the end of the file because 687 // an unshift sequence should have been written at the end. 688 __state_type __state = _M_state_beg; 689 off_type __computed_off = __off * __width; 690 if (_M_reading && __way == ios_base::cur) 691 { 692 if (_M_codecvt->always_noconv()) 693 __computed_off += this->gptr() - this->egptr(); 694 else 695 { 696 // Calculate offset from _M_ext_buf that corresponds 697 // to gptr(). Note: uses _M_state_last, which 698 // corresponds to eback(). 699 const int __gptr_off = 700 _M_codecvt->length(_M_state_last, _M_ext_buf, _M_ext_next, 701 this->gptr() - this->eback()); 702 __computed_off += _M_ext_buf + __gptr_off - _M_ext_end; 703 704 // _M_state_last is modified by codecvt::length() so 705 // it now corresponds to gptr(). 706 __state = _M_state_last; 707 } 708 } 709 __ret = _M_seek(__computed_off, __way, __state); 710 } 711 return __ret; 712 } 713 714 // _GLIBCXX_RESOLVE_LIB_DEFECTS 715 // 171. Strange seekpos() semantics due to joint position 716 // According to the resolution of DR 171, seekpos should ignore the last 717 // argument (of type openmode). 718 template<typename _CharT, typename _Traits> 719 typename basic_filebuf<_CharT, _Traits>::pos_type 720 basic_filebuf<_CharT, _Traits>:: 721 seekpos(pos_type __pos, ios_base::openmode) 722 { 723 pos_type __ret = pos_type(off_type(-1)); 724 if (this->is_open()) 725 { 726 // Ditch any pback buffers to avoid confusion. 727 _M_destroy_pback(); 728 __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state()); 729 } 730 return __ret; 731 } 732 733 template<typename _CharT, typename _Traits> 734 typename basic_filebuf<_CharT, _Traits>::pos_type 735 basic_filebuf<_CharT, _Traits>:: 736 _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state) 737 { 738 pos_type __ret = pos_type(off_type(-1)); 739 if (_M_terminate_output()) 740 { 741 // Returns pos_type(off_type(-1)) in case of failure. 742 __ret = pos_type(_M_file.seekoff(__off, __way)); 743 if (__ret != pos_type(off_type(-1))) 744 { 745 _M_reading = false; 746 _M_writing = false; 747 _M_ext_next = _M_ext_end = _M_ext_buf; 748 _M_set_buffer(-1); 749 _M_state_cur = __state; 750 __ret.state(_M_state_cur); 751 } 752 } 753 return __ret; 754 } 755 756 template<typename _CharT, typename _Traits> 757 bool 758 basic_filebuf<_CharT, _Traits>:: 759 _M_terminate_output() 760 { 761 // Part one: update the output sequence. 762 bool __testvalid = true; 763 if (this->pbase() < this->pptr()) 764 { 765 const int_type __tmp = this->overflow(); 766 if (traits_type::eq_int_type(__tmp, traits_type::eof())) 767 __testvalid = false; 768 } 769 770 // Part two: output unshift sequence. 771 if (_M_writing && !__check_facet(_M_codecvt).always_noconv() 772 && __testvalid) 773 { 774 // Note: this value is arbitrary, since there is no way to 775 // get the length of the unshift sequence from codecvt, 776 // without calling unshift. 777 const size_t __blen = 128; 778 char __buf[__blen]; 779 codecvt_base::result __r; 780 streamsize __ilen = 0; 781 782 do 783 { 784 char* __next; 785 __r = _M_codecvt->unshift(_M_state_cur, __buf, 786 __buf + __blen, __next); 787 if (__r == codecvt_base::error) 788 __testvalid = false; 789 else if (__r == codecvt_base::ok || 790 __r == codecvt_base::partial) 791 { 792 __ilen = __next - __buf; 793 if (__ilen > 0) 794 { 795 const streamsize __elen = _M_file.xsputn(__buf, __ilen); 796 if (__elen != __ilen) 797 __testvalid = false; 798 } 799 } 800 } 801 while (__r == codecvt_base::partial && __ilen > 0 && __testvalid); 802 803 if (__testvalid) 804 { 805 // This second call to overflow() is required by the standard, 806 // but it's not clear why it's needed, since the output buffer 807 // should be empty by this point (it should have been emptied 808 // in the first call to overflow()). 809 const int_type __tmp = this->overflow(); 810 if (traits_type::eq_int_type(__tmp, traits_type::eof())) 811 __testvalid = false; 812 } 813 } 814 return __testvalid; 815 } 816 817 template<typename _CharT, typename _Traits> 818 int 819 basic_filebuf<_CharT, _Traits>:: 820 sync() 821 { 822 // Make sure that the internal buffer resyncs its idea of 823 // the file position with the external file. 824 int __ret = 0; 825 if (this->pbase() < this->pptr()) 826 { 827 const int_type __tmp = this->overflow(); 828 if (traits_type::eq_int_type(__tmp, traits_type::eof())) 829 __ret = -1; 830 } 831 return __ret; 832 } 833 834 template<typename _CharT, typename _Traits> 835 void 836 basic_filebuf<_CharT, _Traits>:: 837 imbue(const locale& __loc) 838 { 839 bool __testvalid = true; 840 841 const __codecvt_type* _M_codecvt_tmp = 0; 842 if (__builtin_expect(has_facet<__codecvt_type>(__loc), true)) 843 _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc); 844 845 if (this->is_open()) 846 { 847 // encoding() == -1 is ok only at the beginning. 848 if ((_M_reading || _M_writing) 849 && __check_facet(_M_codecvt).encoding() == -1) 850 __testvalid = false; 851 else 852 { 853 if (_M_reading) 854 { 855 if (__check_facet(_M_codecvt).always_noconv()) 856 { 857 if (_M_codecvt_tmp 858 && !__check_facet(_M_codecvt_tmp).always_noconv()) 859 __testvalid = this->seekoff(0, ios_base::cur, _M_mode) 860 != pos_type(off_type(-1)); 861 } 862 else 863 { 864 // External position corresponding to gptr(). 865 _M_ext_next = _M_ext_buf 866 + _M_codecvt->length(_M_state_last, _M_ext_buf, _M_ext_next, 867 this->gptr() - this->eback()); 868 const streamsize __remainder = _M_ext_end - _M_ext_next; 869 if (__remainder) 870 std::memmove(_M_ext_buf, _M_ext_next, __remainder); 871 872 _M_ext_next = _M_ext_buf; 873 _M_ext_end = _M_ext_buf + __remainder; 874 _M_set_buffer(-1); 875 _M_state_last = _M_state_cur = _M_state_beg; 876 } 877 } 878 else if (_M_writing && (__testvalid = _M_terminate_output())) 879 _M_set_buffer(-1); 880 } 881 } 882 883 if (__testvalid) 884 _M_codecvt = _M_codecvt_tmp; 885 else 886 _M_codecvt = 0; 887 } 888 889 // Inhibit implicit instantiations for required instantiations, 890 // which are defined via explicit instantiations elsewhere. 891 // NB: This syntax is a GNU extension. 892#if _GLIBCXX_EXTERN_TEMPLATE 893 extern template class basic_filebuf<char>; 894 extern template class basic_ifstream<char>; 895 extern template class basic_ofstream<char>; 896 extern template class basic_fstream<char>; 897 898#ifdef _GLIBCXX_USE_WCHAR_T 899 extern template class basic_filebuf<wchar_t>; 900 extern template class basic_ifstream<wchar_t>; 901 extern template class basic_ofstream<wchar_t>; 902 extern template class basic_fstream<wchar_t>; 903#endif 904#endif 905} // namespace std 906 907#endif 908