libstdc++
fstream.tcc
Go to the documentation of this file.
1 // File based streams -*- C++ -*-
2 
3 // Copyright (C) 1997-2015 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/fstream.tcc
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{fstream}
28  */
29 
30 //
31 // ISO C++ 14882: 27.8 File-based streams
32 //
33 
34 #ifndef _FSTREAM_TCC
35 #define _FSTREAM_TCC 1
36 
37 #pragma GCC system_header
38 
39 #include <bits/cxxabi_forced.h>
40 #include <bits/move.h> // for swap
41 
42 namespace std _GLIBCXX_VISIBILITY(default)
43 {
44 _GLIBCXX_BEGIN_NAMESPACE_VERSION
45 
46  template<typename _CharT, typename _Traits>
47  void
48  basic_filebuf<_CharT, _Traits>::
49  _M_allocate_internal_buffer()
50  {
51  // Allocate internal buffer only if one doesn't already exist
52  // (either allocated or provided by the user via setbuf).
53  if (!_M_buf_allocated && !_M_buf)
54  {
55  _M_buf = new char_type[_M_buf_size];
56  _M_buf_allocated = true;
57  }
58  }
59 
60  template<typename _CharT, typename _Traits>
61  void
62  basic_filebuf<_CharT, _Traits>::
63  _M_destroy_internal_buffer() throw()
64  {
65  if (_M_buf_allocated)
66  {
67  delete [] _M_buf;
68  _M_buf = 0;
69  _M_buf_allocated = false;
70  }
71  delete [] _M_ext_buf;
72  _M_ext_buf = 0;
73  _M_ext_buf_size = 0;
74  _M_ext_next = 0;
75  _M_ext_end = 0;
76  }
77 
78  template<typename _CharT, typename _Traits>
80  basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
81  _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
82  _M_state_last(), _M_buf(0), _M_buf_size(BUFSIZ),
83  _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
84  _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
85  _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
86  _M_ext_end(0)
87  {
88  if (has_facet<__codecvt_type>(this->_M_buf_locale))
89  _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
90  }
91 
92 #if __cplusplus >= 201103L
93  template<typename _CharT, typename _Traits>
96  : __streambuf_type(__rhs),
97  _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock),
98  _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))),
99  _M_state_beg(std::move(__rhs._M_state_beg)),
100  _M_state_cur(std::move(__rhs._M_state_cur)),
101  _M_state_last(std::move(__rhs._M_state_last)),
102  _M_buf(std::__exchange(__rhs._M_buf, nullptr)),
103  _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)),
104  _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)),
105  _M_reading(std::__exchange(__rhs._M_reading, false)),
106  _M_writing(std::__exchange(__rhs._M_writing, false)),
107  _M_pback(__rhs._M_pback),
108  _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)),
109  _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)),
110  _M_pback_init(std::__exchange(__rhs._M_pback_init, false)),
111  _M_codecvt(__rhs._M_codecvt),
112  _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)),
113  _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)),
114  _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)),
115  _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr))
116  {
117  __rhs._M_set_buffer(-1);
118  __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
119  }
120 
121  template<typename _CharT, typename _Traits>
124  operator=(basic_filebuf&& __rhs)
125  {
126  this->close();
127  __streambuf_type::operator=(__rhs);
128  _M_file.swap(__rhs._M_file);
129  _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0));
130  _M_state_beg = std::move(__rhs._M_state_beg);
131  _M_state_cur = std::move(__rhs._M_state_cur);
132  _M_state_last = std::move(__rhs._M_state_last);
133  _M_buf = std::__exchange(__rhs._M_buf, nullptr);
134  _M_buf_size = std::__exchange(__rhs._M_buf_size, 1);
135  _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false);
136  _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr);
137  _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0);
138  _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr);
139  _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr);
140  _M_reading = std::__exchange(__rhs._M_reading, false);
141  _M_writing = std::__exchange(__rhs._M_writing, false);
142  _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr);
143  _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr);
144  _M_pback_init = std::__exchange(__rhs._M_pback_init, false);
145  __rhs._M_set_buffer(-1);
146  __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
147  return *this;
148  }
149 
150  template<typename _CharT, typename _Traits>
151  void
153  swap(basic_filebuf& __rhs)
154  {
155  __streambuf_type::swap(__rhs);
156  _M_file.swap(__rhs._M_file);
157  std::swap(_M_mode, __rhs._M_mode);
158  std::swap(_M_state_beg, __rhs._M_state_beg);
159  std::swap(_M_state_cur, __rhs._M_state_cur);
160  std::swap(_M_state_last, __rhs._M_state_last);
161  std::swap(_M_buf, __rhs._M_buf);
162  std::swap(_M_buf_size, __rhs._M_buf_size);
163  std::swap(_M_buf_allocated, __rhs._M_buf_allocated);
164  std::swap(_M_ext_buf, __rhs._M_ext_buf);
165  std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size);
166  std::swap(_M_ext_next, __rhs._M_ext_next);
167  std::swap(_M_ext_end, __rhs._M_ext_end);
168  std::swap(_M_reading, __rhs._M_reading);
169  std::swap(_M_writing, __rhs._M_writing);
170  std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save);
171  std::swap(_M_pback_end_save, __rhs._M_pback_end_save);
172  std::swap(_M_pback_init, __rhs._M_pback_init);
173  }
174 #endif
175 
176  template<typename _CharT, typename _Traits>
179  open(const char* __s, ios_base::openmode __mode)
180  {
181  __filebuf_type *__ret = 0;
182  if (!this->is_open())
183  {
184  _M_file.open(__s, __mode);
185  if (this->is_open())
186  {
187  _M_allocate_internal_buffer();
188  _M_mode = __mode;
189 
190  // Setup initial buffer to 'uncommitted' mode.
191  _M_reading = false;
192  _M_writing = false;
193  _M_set_buffer(-1);
194 
195  // Reset to initial state.
196  _M_state_last = _M_state_cur = _M_state_beg;
197 
198  // 27.8.1.3,4
199  if ((__mode & ios_base::ate)
200  && this->seekoff(0, ios_base::end, __mode)
201  == pos_type(off_type(-1)))
202  this->close();
203  else
204  __ret = this;
205  }
206  }
207  return __ret;
208  }
209 
210  template<typename _CharT, typename _Traits>
214  {
215  if (!this->is_open())
216  return 0;
217 
218  bool __testfail = false;
219  {
220  // NB: Do this here so that re-opened filebufs will be cool...
221  struct __close_sentry
222  {
223  basic_filebuf *__fb;
224  __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
225  ~__close_sentry ()
226  {
227  __fb->_M_mode = ios_base::openmode(0);
228  __fb->_M_pback_init = false;
229  __fb->_M_destroy_internal_buffer();
230  __fb->_M_reading = false;
231  __fb->_M_writing = false;
232  __fb->_M_set_buffer(-1);
233  __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
234  }
235  } __cs (this);
236 
237  __try
238  {
239  if (!_M_terminate_output())
240  __testfail = true;
241  }
243  {
244  _M_file.close();
245  __throw_exception_again;
246  }
247  __catch(...)
248  { __testfail = true; }
249  }
250 
251  if (!_M_file.close())
252  __testfail = true;
253 
254  if (__testfail)
255  return 0;
256  else
257  return this;
258  }
259 
260  template<typename _CharT, typename _Traits>
261  streamsize
264  {
265  streamsize __ret = -1;
266  const bool __testin = _M_mode & ios_base::in;
267  if (__testin && this->is_open())
268  {
269  // For a stateful encoding (-1) the pending sequence might be just
270  // shift and unshift prefixes with no actual character.
271  __ret = this->egptr() - this->gptr();
272 
273 #if _GLIBCXX_HAVE_DOS_BASED_FILESYSTEM
274  // About this workaround, see libstdc++/20806.
275  const bool __testbinary = _M_mode & ios_base::binary;
276  if (__check_facet(_M_codecvt).encoding() >= 0
277  && __testbinary)
278 #else
279  if (__check_facet(_M_codecvt).encoding() >= 0)
280 #endif
281  __ret += _M_file.showmanyc() / _M_codecvt->max_length();
282  }
283  return __ret;
284  }
285 
286  template<typename _CharT, typename _Traits>
287  typename basic_filebuf<_CharT, _Traits>::int_type
290  {
291  int_type __ret = traits_type::eof();
292  const bool __testin = _M_mode & ios_base::in;
293  if (__testin)
294  {
295  if (_M_writing)
296  {
297  if (overflow() == traits_type::eof())
298  return __ret;
299  _M_set_buffer(-1);
300  _M_writing = false;
301  }
302  // Check for pback madness, and if so switch back to the
303  // normal buffers and jet outta here before expensive
304  // fileops happen...
306 
307  if (this->gptr() < this->egptr())
308  return traits_type::to_int_type(*this->gptr());
309 
310  // Get and convert input sequence.
311  const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
312 
313  // Will be set to true if ::read() returns 0 indicating EOF.
314  bool __got_eof = false;
315  // Number of internal characters produced.
316  streamsize __ilen = 0;
317  codecvt_base::result __r = codecvt_base::ok;
318  if (__check_facet(_M_codecvt).always_noconv())
319  {
320  __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
321  __buflen);
322  if (__ilen == 0)
323  __got_eof = true;
324  }
325  else
326  {
327  // Worst-case number of external bytes.
328  // XXX Not done encoding() == -1.
329  const int __enc = _M_codecvt->encoding();
330  streamsize __blen; // Minimum buffer size.
331  streamsize __rlen; // Number of chars to read.
332  if (__enc > 0)
333  __blen = __rlen = __buflen * __enc;
334  else
335  {
336  __blen = __buflen + _M_codecvt->max_length() - 1;
337  __rlen = __buflen;
338  }
339  const streamsize __remainder = _M_ext_end - _M_ext_next;
340  __rlen = __rlen > __remainder ? __rlen - __remainder : 0;
341 
342  // An imbue in 'read' mode implies first converting the external
343  // chars already present.
344  if (_M_reading && this->egptr() == this->eback() && __remainder)
345  __rlen = 0;
346 
347  // Allocate buffer if necessary and move unconverted
348  // bytes to front.
349  if (_M_ext_buf_size < __blen)
350  {
351  char* __buf = new char[__blen];
352  if (__remainder)
353  __builtin_memcpy(__buf, _M_ext_next, __remainder);
354 
355  delete [] _M_ext_buf;
356  _M_ext_buf = __buf;
357  _M_ext_buf_size = __blen;
358  }
359  else if (__remainder)
360  __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
361 
362  _M_ext_next = _M_ext_buf;
363  _M_ext_end = _M_ext_buf + __remainder;
364  _M_state_last = _M_state_cur;
365 
366  do
367  {
368  if (__rlen > 0)
369  {
370  // Sanity check!
371  // This may fail if the return value of
372  // codecvt::max_length() is bogus.
373  if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
374  {
375  __throw_ios_failure(__N("basic_filebuf::underflow "
376  "codecvt::max_length() "
377  "is not valid"));
378  }
379  streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
380  if (__elen == 0)
381  __got_eof = true;
382  else if (__elen == -1)
383  break;
384  _M_ext_end += __elen;
385  }
386 
387  char_type* __iend = this->eback();
388  if (_M_ext_next < _M_ext_end)
389  __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
390  _M_ext_end, _M_ext_next,
391  this->eback(),
392  this->eback() + __buflen, __iend);
393  if (__r == codecvt_base::noconv)
394  {
395  size_t __avail = _M_ext_end - _M_ext_buf;
396  __ilen = std::min(__avail, __buflen);
397  traits_type::copy(this->eback(),
398  reinterpret_cast<char_type*>
399  (_M_ext_buf), __ilen);
400  _M_ext_next = _M_ext_buf + __ilen;
401  }
402  else
403  __ilen = __iend - this->eback();
404 
405  // _M_codecvt->in may return error while __ilen > 0: this is
406  // ok, and actually occurs in case of mixed encodings (e.g.,
407  // XML files).
408  if (__r == codecvt_base::error)
409  break;
410 
411  __rlen = 1;
412  }
413  while (__ilen == 0 && !__got_eof);
414  }
415 
416  if (__ilen > 0)
417  {
418  _M_set_buffer(__ilen);
419  _M_reading = true;
420  __ret = traits_type::to_int_type(*this->gptr());
421  }
422  else if (__got_eof)
423  {
424  // If the actual end of file is reached, set 'uncommitted'
425  // mode, thus allowing an immediate write without an
426  // intervening seek.
427  _M_set_buffer(-1);
428  _M_reading = false;
429  // However, reaching it while looping on partial means that
430  // the file has got an incomplete character.
431  if (__r == codecvt_base::partial)
432  __throw_ios_failure(__N("basic_filebuf::underflow "
433  "incomplete character in file"));
434  }
435  else if (__r == codecvt_base::error)
436  __throw_ios_failure(__N("basic_filebuf::underflow "
437  "invalid byte sequence in file"));
438  else
439  __throw_ios_failure(__N("basic_filebuf::underflow "
440  "error reading the file"));
441  }
442  return __ret;
443  }
444 
445  template<typename _CharT, typename _Traits>
446  typename basic_filebuf<_CharT, _Traits>::int_type
448  pbackfail(int_type __i)
449  {
450  int_type __ret = traits_type::eof();
451  const bool __testin = _M_mode & ios_base::in;
452  if (__testin)
453  {
454  if (_M_writing)
455  {
456  if (overflow() == traits_type::eof())
457  return __ret;
458  _M_set_buffer(-1);
459  _M_writing = false;
460  }
461  // Remember whether the pback buffer is active, otherwise below
462  // we may try to store in it a second char (libstdc++/9761).
463  const bool __testpb = _M_pback_init;
464  const bool __testeof = traits_type::eq_int_type(__i, __ret);
465  int_type __tmp;
466  if (this->eback() < this->gptr())
467  {
468  this->gbump(-1);
469  __tmp = traits_type::to_int_type(*this->gptr());
470  }
471  else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
472  {
473  __tmp = this->underflow();
474  if (traits_type::eq_int_type(__tmp, __ret))
475  return __ret;
476  }
477  else
478  {
479  // At the beginning of the buffer, need to make a
480  // putback position available. But the seek may fail
481  // (f.i., at the beginning of a file, see
482  // libstdc++/9439) and in that case we return
483  // traits_type::eof().
484  return __ret;
485  }
486 
487  // Try to put back __i into input sequence in one of three ways.
488  // Order these tests done in is unspecified by the standard.
489  if (!__testeof && traits_type::eq_int_type(__i, __tmp))
490  __ret = __i;
491  else if (__testeof)
492  __ret = traits_type::not_eof(__i);
493  else if (!__testpb)
494  {
495  _M_create_pback();
496  _M_reading = true;
497  *this->gptr() = traits_type::to_char_type(__i);
498  __ret = __i;
499  }
500  }
501  return __ret;
502  }
503 
504  template<typename _CharT, typename _Traits>
505  typename basic_filebuf<_CharT, _Traits>::int_type
507  overflow(int_type __c)
508  {
509  int_type __ret = traits_type::eof();
510  const bool __testeof = traits_type::eq_int_type(__c, __ret);
511  const bool __testout = (_M_mode & ios_base::out
512  || _M_mode & ios_base::app);
513  if (__testout)
514  {
515  if (_M_reading)
516  {
518  const int __gptr_off = _M_get_ext_pos(_M_state_last);
519  if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
520  == pos_type(off_type(-1)))
521  return __ret;
522  }
523  if (this->pbase() < this->pptr())
524  {
525  // If appropriate, append the overflow char.
526  if (!__testeof)
527  {
528  *this->pptr() = traits_type::to_char_type(__c);
529  this->pbump(1);
530  }
531 
532  // Convert pending sequence to external representation,
533  // and output.
534  if (_M_convert_to_external(this->pbase(),
535  this->pptr() - this->pbase()))
536  {
537  _M_set_buffer(0);
538  __ret = traits_type::not_eof(__c);
539  }
540  }
541  else if (_M_buf_size > 1)
542  {
543  // Overflow in 'uncommitted' mode: set _M_writing, set
544  // the buffer to the initial 'write' mode, and put __c
545  // into the buffer.
546  _M_set_buffer(0);
547  _M_writing = true;
548  if (!__testeof)
549  {
550  *this->pptr() = traits_type::to_char_type(__c);
551  this->pbump(1);
552  }
553  __ret = traits_type::not_eof(__c);
554  }
555  else
556  {
557  // Unbuffered.
558  char_type __conv = traits_type::to_char_type(__c);
559  if (__testeof || _M_convert_to_external(&__conv, 1))
560  {
561  _M_writing = true;
562  __ret = traits_type::not_eof(__c);
563  }
564  }
565  }
566  return __ret;
567  }
568 
569  template<typename _CharT, typename _Traits>
570  bool
572  _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
573  {
574  // Sizes of external and pending output.
575  streamsize __elen;
576  streamsize __plen;
577  if (__check_facet(_M_codecvt).always_noconv())
578  {
579  __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
580  __plen = __ilen;
581  }
582  else
583  {
584  // Worst-case number of external bytes needed.
585  // XXX Not done encoding() == -1.
586  streamsize __blen = __ilen * _M_codecvt->max_length();
587  char* __buf = static_cast<char*>(__builtin_alloca(__blen));
588 
589  char* __bend;
590  const char_type* __iend;
591  codecvt_base::result __r;
592  __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
593  __iend, __buf, __buf + __blen, __bend);
594 
595  if (__r == codecvt_base::ok || __r == codecvt_base::partial)
596  __blen = __bend - __buf;
597  else if (__r == codecvt_base::noconv)
598  {
599  // Same as the always_noconv case above.
600  __buf = reinterpret_cast<char*>(__ibuf);
601  __blen = __ilen;
602  }
603  else
604  __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external "
605  "conversion error"));
606 
607  __elen = _M_file.xsputn(__buf, __blen);
608  __plen = __blen;
609 
610  // Try once more for partial conversions.
611  if (__r == codecvt_base::partial && __elen == __plen)
612  {
613  const char_type* __iresume = __iend;
614  streamsize __rlen = this->pptr() - __iend;
615  __r = _M_codecvt->out(_M_state_cur, __iresume,
616  __iresume + __rlen, __iend, __buf,
617  __buf + __blen, __bend);
618  if (__r != codecvt_base::error)
619  {
620  __rlen = __bend - __buf;
621  __elen = _M_file.xsputn(__buf, __rlen);
622  __plen = __rlen;
623  }
624  else
625  __throw_ios_failure(__N("basic_filebuf::_M_convert_to_external "
626  "conversion error"));
627  }
628  }
629  return __elen == __plen;
630  }
631 
632  template<typename _CharT, typename _Traits>
633  streamsize
635  xsgetn(_CharT* __s, streamsize __n)
636  {
637  // Clear out pback buffer before going on to the real deal...
638  streamsize __ret = 0;
639  if (_M_pback_init)
640  {
641  if (__n > 0 && this->gptr() == this->eback())
642  {
643  *__s++ = *this->gptr(); // emulate non-underflowing sbumpc
644  this->gbump(1);
645  __ret = 1;
646  --__n;
647  }
649  }
650  else if (_M_writing)
651  {
652  if (overflow() == traits_type::eof())
653  return __ret;
654  _M_set_buffer(-1);
655  _M_writing = false;
656  }
657 
658  // Optimization in the always_noconv() case, to be generalized in the
659  // future: when __n > __buflen we read directly instead of using the
660  // buffer repeatedly.
661  const bool __testin = _M_mode & ios_base::in;
662  const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
663 
664  if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
665  && __testin)
666  {
667  // First, copy the chars already present in the buffer.
668  const streamsize __avail = this->egptr() - this->gptr();
669  if (__avail != 0)
670  {
671  traits_type::copy(__s, this->gptr(), __avail);
672  __s += __avail;
673  this->setg(this->eback(), this->gptr() + __avail,
674  this->egptr());
675  __ret += __avail;
676  __n -= __avail;
677  }
678 
679  // Need to loop in case of short reads (relatively common
680  // with pipes).
681  streamsize __len;
682  for (;;)
683  {
684  __len = _M_file.xsgetn(reinterpret_cast<char*>(__s),
685  __n);
686  if (__len == -1)
687  __throw_ios_failure(__N("basic_filebuf::xsgetn "
688  "error reading the file"));
689  if (__len == 0)
690  break;
691 
692  __n -= __len;
693  __ret += __len;
694  if (__n == 0)
695  break;
696 
697  __s += __len;
698  }
699 
700  if (__n == 0)
701  {
702  _M_set_buffer(0);
703  _M_reading = true;
704  }
705  else if (__len == 0)
706  {
707  // If end of file is reached, set 'uncommitted'
708  // mode, thus allowing an immediate write without
709  // an intervening seek.
710  _M_set_buffer(-1);
711  _M_reading = false;
712  }
713  }
714  else
715  __ret += __streambuf_type::xsgetn(__s, __n);
716 
717  return __ret;
718  }
719 
720  template<typename _CharT, typename _Traits>
721  streamsize
723  xsputn(const _CharT* __s, streamsize __n)
724  {
725  streamsize __ret = 0;
726  // Optimization in the always_noconv() case, to be generalized in the
727  // future: when __n is sufficiently large we write directly instead of
728  // using the buffer.
729  const bool __testout = (_M_mode & ios_base::out
730  || _M_mode & ios_base::app);
731  if (__check_facet(_M_codecvt).always_noconv()
732  && __testout && !_M_reading)
733  {
734  // Measurement would reveal the best choice.
735  const streamsize __chunk = 1ul << 10;
736  streamsize __bufavail = this->epptr() - this->pptr();
737 
738  // Don't mistake 'uncommitted' mode buffered with unbuffered.
739  if (!_M_writing && _M_buf_size > 1)
740  __bufavail = _M_buf_size - 1;
741 
742  const streamsize __limit = std::min(__chunk, __bufavail);
743  if (__n >= __limit)
744  {
745  const streamsize __buffill = this->pptr() - this->pbase();
746  const char* __buf = reinterpret_cast<const char*>(this->pbase());
747  __ret = _M_file.xsputn_2(__buf, __buffill,
748  reinterpret_cast<const char*>(__s),
749  __n);
750  if (__ret == __buffill + __n)
751  {
752  _M_set_buffer(0);
753  _M_writing = true;
754  }
755  if (__ret > __buffill)
756  __ret -= __buffill;
757  else
758  __ret = 0;
759  }
760  else
761  __ret = __streambuf_type::xsputn(__s, __n);
762  }
763  else
764  __ret = __streambuf_type::xsputn(__s, __n);
765  return __ret;
766  }
767 
768  template<typename _CharT, typename _Traits>
771  setbuf(char_type* __s, streamsize __n)
772  {
773  if (!this->is_open())
774  {
775  if (__s == 0 && __n == 0)
776  _M_buf_size = 1;
777  else if (__s && __n > 0)
778  {
779  // This is implementation-defined behavior, and assumes that
780  // an external char_type array of length __n exists and has
781  // been pre-allocated. If this is not the case, things will
782  // quickly blow up. When __n > 1, __n - 1 positions will be
783  // used for the get area, __n - 1 for the put area and 1
784  // position to host the overflow char of a full put area.
785  // When __n == 1, 1 position will be used for the get area
786  // and 0 for the put area, as in the unbuffered case above.
787  _M_buf = __s;
788  _M_buf_size = __n;
789  }
790  }
791  return this;
792  }
793 
794 
795  // According to 27.8.1.4 p11 - 13, seekoff should ignore the last
796  // argument (of type openmode).
797  template<typename _CharT, typename _Traits>
798  typename basic_filebuf<_CharT, _Traits>::pos_type
800  seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
801  {
802  int __width = 0;
803  if (_M_codecvt)
804  __width = _M_codecvt->encoding();
805  if (__width < 0)
806  __width = 0;
807 
808  pos_type __ret = pos_type(off_type(-1));
809  const bool __testfail = __off != 0 && __width <= 0;
810  if (this->is_open() && !__testfail)
811  {
812  // tellg and tellp queries do not affect any state, unless
813  // ! always_noconv and the put sequence is not empty.
814  // In that case, determining the position requires converting the
815  // put sequence. That doesn't use ext_buf, so requires a flush.
816  bool __no_movement = __way == ios_base::cur && __off == 0
817  && (!_M_writing || _M_codecvt->always_noconv());
818 
819  // Ditch any pback buffers to avoid confusion.
820  if (!__no_movement)
822 
823  // Correct state at destination. Note that this is the correct
824  // state for the current position during output, because
825  // codecvt::unshift() returns the state to the initial state.
826  // This is also the correct state at the end of the file because
827  // an unshift sequence should have been written at the end.
828  __state_type __state = _M_state_beg;
829  off_type __computed_off = __off * __width;
830  if (_M_reading && __way == ios_base::cur)
831  {
832  __state = _M_state_last;
833  __computed_off += _M_get_ext_pos(__state);
834  }
835  if (!__no_movement)
836  __ret = _M_seek(__computed_off, __way, __state);
837  else
838  {
839  if (_M_writing)
840  __computed_off = this->pptr() - this->pbase();
841 
842  off_type __file_off = _M_file.seekoff(0, ios_base::cur);
843  if (__file_off != off_type(-1))
844  {
845  __ret = __file_off + __computed_off;
846  __ret.state(__state);
847  }
848  }
849  }
850  return __ret;
851  }
852 
853  // _GLIBCXX_RESOLVE_LIB_DEFECTS
854  // 171. Strange seekpos() semantics due to joint position
855  // According to the resolution of DR 171, seekpos should ignore the last
856  // argument (of type openmode).
857  template<typename _CharT, typename _Traits>
858  typename basic_filebuf<_CharT, _Traits>::pos_type
860  seekpos(pos_type __pos, ios_base::openmode)
861  {
862  pos_type __ret = pos_type(off_type(-1));
863  if (this->is_open())
864  {
865  // Ditch any pback buffers to avoid confusion.
867  __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
868  }
869  return __ret;
870  }
871 
872  template<typename _CharT, typename _Traits>
873  typename basic_filebuf<_CharT, _Traits>::pos_type
875  _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
876  {
877  pos_type __ret = pos_type(off_type(-1));
878  if (_M_terminate_output())
879  {
880  off_type __file_off = _M_file.seekoff(__off, __way);
881  if (__file_off != off_type(-1))
882  {
883  _M_reading = false;
884  _M_writing = false;
885  _M_ext_next = _M_ext_end = _M_ext_buf;
886  _M_set_buffer(-1);
887  _M_state_cur = __state;
888  __ret = __file_off;
889  __ret.state(_M_state_cur);
890  }
891  }
892  return __ret;
893  }
894 
895  // Returns the distance from the end of the ext buffer to the point
896  // corresponding to gptr(). This is a negative value. Updates __state
897  // from eback() correspondence to gptr().
898  template<typename _CharT, typename _Traits>
900  _M_get_ext_pos(__state_type& __state)
901  {
902  if (_M_codecvt->always_noconv())
903  return this->gptr() - this->egptr();
904  else
905  {
906  // Calculate offset from _M_ext_buf that corresponds to
907  // gptr(). Precondition: __state == _M_state_last, which
908  // corresponds to eback().
909  const int __gptr_off =
910  _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
911  this->gptr() - this->eback());
912  return _M_ext_buf + __gptr_off - _M_ext_end;
913  }
914  }
915 
916  template<typename _CharT, typename _Traits>
917  bool
920  {
921  // Part one: update the output sequence.
922  bool __testvalid = true;
923  if (this->pbase() < this->pptr())
924  {
925  const int_type __tmp = this->overflow();
926  if (traits_type::eq_int_type(__tmp, traits_type::eof()))
927  __testvalid = false;
928  }
929 
930  // Part two: output unshift sequence.
931  if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
932  && __testvalid)
933  {
934  // Note: this value is arbitrary, since there is no way to
935  // get the length of the unshift sequence from codecvt,
936  // without calling unshift.
937  const size_t __blen = 128;
938  char __buf[__blen];
939  codecvt_base::result __r;
940  streamsize __ilen = 0;
941 
942  do
943  {
944  char* __next;
945  __r = _M_codecvt->unshift(_M_state_cur, __buf,
946  __buf + __blen, __next);
947  if (__r == codecvt_base::error)
948  __testvalid = false;
949  else if (__r == codecvt_base::ok ||
950  __r == codecvt_base::partial)
951  {
952  __ilen = __next - __buf;
953  if (__ilen > 0)
954  {
955  const streamsize __elen = _M_file.xsputn(__buf, __ilen);
956  if (__elen != __ilen)
957  __testvalid = false;
958  }
959  }
960  }
961  while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);
962 
963  if (__testvalid)
964  {
965  // This second call to overflow() is required by the standard,
966  // but it's not clear why it's needed, since the output buffer
967  // should be empty by this point (it should have been emptied
968  // in the first call to overflow()).
969  const int_type __tmp = this->overflow();
970  if (traits_type::eq_int_type(__tmp, traits_type::eof()))
971  __testvalid = false;
972  }
973  }
974  return __testvalid;
975  }
976 
977  template<typename _CharT, typename _Traits>
978  int
981  {
982  // Make sure that the internal buffer resyncs its idea of
983  // the file position with the external file.
984  int __ret = 0;
985  if (this->pbase() < this->pptr())
986  {
987  const int_type __tmp = this->overflow();
988  if (traits_type::eq_int_type(__tmp, traits_type::eof()))
989  __ret = -1;
990  }
991  return __ret;
992  }
993 
994  template<typename _CharT, typename _Traits>
995  void
997  imbue(const locale& __loc)
998  {
999  bool __testvalid = true;
1000 
1001  const __codecvt_type* _M_codecvt_tmp = 0;
1002  if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
1003  _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);
1004 
1005  if (this->is_open())
1006  {
1007  // encoding() == -1 is ok only at the beginning.
1008  if ((_M_reading || _M_writing)
1009  && __check_facet(_M_codecvt).encoding() == -1)
1010  __testvalid = false;
1011  else
1012  {
1013  if (_M_reading)
1014  {
1015  if (__check_facet(_M_codecvt).always_noconv())
1016  {
1017  if (_M_codecvt_tmp
1018  && !__check_facet(_M_codecvt_tmp).always_noconv())
1019  __testvalid = this->seekoff(0, ios_base::cur, _M_mode)
1020  != pos_type(off_type(-1));
1021  }
1022  else
1023  {
1024  // External position corresponding to gptr().
1026  + _M_codecvt->length(_M_state_last, _M_ext_buf,
1027  _M_ext_next,
1028  this->gptr() - this->eback());
1029  const streamsize __remainder = _M_ext_end - _M_ext_next;
1030  if (__remainder)
1031  __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
1032 
1033  _M_ext_next = _M_ext_buf;
1034  _M_ext_end = _M_ext_buf + __remainder;
1035  _M_set_buffer(-1);
1036  _M_state_last = _M_state_cur = _M_state_beg;
1037  }
1038  }
1039  else if (_M_writing && (__testvalid = _M_terminate_output()))
1040  _M_set_buffer(-1);
1041  }
1042  }
1043 
1044  if (__testvalid)
1045  _M_codecvt = _M_codecvt_tmp;
1046  else
1047  _M_codecvt = 0;
1048  }
1049 
1050  // Inhibit implicit instantiations for required instantiations,
1051  // which are defined via explicit instantiations elsewhere.
1052 #if _GLIBCXX_EXTERN_TEMPLATE
1053  extern template class basic_filebuf<char>;
1054  extern template class basic_ifstream<char>;
1055  extern template class basic_ofstream<char>;
1056  extern template class basic_fstream<char>;
1057 
1058 #ifdef _GLIBCXX_USE_WCHAR_T
1059  extern template class basic_filebuf<wchar_t>;
1060  extern template class basic_ifstream<wchar_t>;
1061  extern template class basic_ofstream<wchar_t>;
1062  extern template class basic_fstream<wchar_t>;
1063 #endif
1064 #endif
1065 
1066 _GLIBCXX_END_NAMESPACE_VERSION
1067 } // namespace std
1068 
1069 #endif
virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode=ios_base::in|ios_base::out)
Alters the stream positions.
Definition: fstream.tcc:860
char_type * eback() const
Access to the get area.
Definition: streambuf:482
virtual int_type underflow()
Fetches more data from the controlled sequence.
Definition: fstream.tcc:289
char_type * egptr() const
Access to the get area.
Definition: streambuf:488
basic_filebuf()
Does not open any files.
Definition: fstream.tcc:80
static const openmode ate
Open and seek to end immediately after opening.
Definition: ios_base.h:435
static const seekdir cur
Request a seek relative to the current position within the sequence.
Definition: ios_base.h:467
char_type * gptr() const
Access to the get area.
Definition: streambuf:485
Controlling input for files.
Definition: fstream:455
The actual work of input and output (interface).
Definition: iosfwd:80
virtual void imbue(const locale &__loc)
Changes translations.
Definition: fstream.tcc:997
virtual __streambuf_type * setbuf(char_type *__s, streamsize __n)
Manipulates the buffer.
Definition: fstream.tcc:771
char_type _M_pback
Definition: fstream:156
char_type * epptr() const
Access to the put area.
Definition: streambuf:535
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
__filebuf_type * close()
Closes the currently associated file.
Definition: fstream.tcc:213
_Ios_Openmode openmode
This is a bitmask type.
Definition: ios_base.h:429
virtual streamsize showmanyc()
Investigating the data available.
Definition: fstream.tcc:263
ios_base::openmode _M_mode
Place to stash in || out || in | out settings for current filebuf.
Definition: fstream:113
char_type * _M_pback_end_save
Definition: fstream:158
char_type * _M_buf
Pointer to the beginning of internal buffer.
Definition: fstream:128
void setg(char_type *__gbeg, char_type *__gnext, char_type *__gend)
Setting the three read area pointers.
Definition: streambuf:509
static const openmode out
Open for output. Default for ofstream and fstream.
Definition: ios_base.h:446
Controlling output for files.
Definition: fstream:656
static const openmode binary
Perform input and output in binary mode (as opposed to text mode). This is probably not what you thin...
Definition: ios_base.h:440
virtual pos_type seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode=ios_base::in|ios_base::out)
Alters the stream positions.
Definition: fstream.tcc:800
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:195
bool is_open() const
Returns true if the external file is open.
Definition: fstream:252
The base of the I/O class hierarchy.This class defines everything that can be defined about I/O that ...
Definition: ios_base.h:228
__filebuf_type * open(const char *__s, ios_base::openmode __mode)
Opens an external file.
Definition: fstream.tcc:179
static const seekdir beg
Request a seek relative to the beginning of the stream.
Definition: ios_base.h:464
static const openmode in
Open for input. Default for ifstream and fstream.
Definition: ios_base.h:443
virtual streamsize xsputn(const char_type *__s, streamsize __n)
Multiple character insertion.
Definition: streambuf.tcc:80
static const seekdir end
Request a seek relative to the current end of the sequence.
Definition: ios_base.h:470
Controlling input and output for files.
Definition: fstream:862
char_type * _M_pback_cur_save
Definition: fstream:157
virtual int sync()
Synchronizes the buffer arrays with the controlled sequences.
Definition: fstream.tcc:980
streamsize _M_ext_buf_size
Definition: fstream:175
void pbump(int __n)
Moving the write position.
Definition: streambuf:545
void gbump(int __n)
Moving the read position.
Definition: streambuf:498
locale _M_buf_locale
Current locale setting.
Definition: streambuf:192
virtual streamsize xsputn(const char_type *__s, streamsize __n)
Multiple character insertion.
Definition: fstream.tcc:723
char_type * pptr() const
Access to the put area.
Definition: streambuf:532
The actual work of input and output (for files).
Definition: fstream:72
virtual int_type pbackfail(int_type __c=_Traits::eof())
Tries to back up the input sequence.
Definition: fstream.tcc:448
bool _M_pback_init
Definition: fstream:159
size_t _M_buf_size
Definition: fstream:135
void _M_set_buffer(streamsize __off)
Definition: fstream:422
void _M_create_pback()
Definition: fstream:191
Primary class template codecvt.NB: Generic, mostly useless implementation.
Definition: codecvt.h:274
Container class for localization functionality.The locale class is first a class wrapper for C librar...
void _M_destroy_pback()
Definition: fstream:208
ISO C++ entities toplevel namespace is std.
virtual streamsize xsgetn(char_type *__s, streamsize __n)
Multiple character extraction.
Definition: fstream.tcc:635
const char * _M_ext_next
Definition: fstream:182
static const openmode app
Seek to end before each write.
Definition: ios_base.h:432
virtual int_type overflow(int_type __c=_Traits::eof())
Consumes data from the buffer; writes to the controlled sequence.
Definition: fstream.tcc:507
virtual streamsize xsgetn(char_type *__s, streamsize __n)
Multiple character extraction.
Definition: streambuf.tcc:46
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
Definition: cxxabi_forced.h:48
char_type * pbase() const
Access to the put area.
Definition: streambuf:529
char * _M_ext_buf
Definition: fstream:170