1    	// File based streams -*- C++ -*-
2    	
3    	// Copyright (C) 1997-2017 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>
79   	    basic_filebuf<_CharT, _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>
94   	    basic_filebuf<_CharT, _Traits>::
95   	    basic_filebuf(basic_filebuf&& __rhs)
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>
122  	    basic_filebuf<_CharT, _Traits>&
123  	    basic_filebuf<_CharT, _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
152  	    basic_filebuf<_CharT, _Traits>::
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>
177  	    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
178  	    basic_filebuf<_CharT, _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>
211  	    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
212  	    basic_filebuf<_CharT, _Traits>::
213  	    close()
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  		  }
242  		__catch(__cxxabiv1::__forced_unwind&)
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
262  	    basic_filebuf<_CharT, _Traits>::
263  	    showmanyc()
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
288  	    basic_filebuf<_CharT, _Traits>::
289  	    underflow()
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...
305  		  _M_destroy_pback();
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
447  	    basic_filebuf<_CharT, _Traits>::
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
506  	    basic_filebuf<_CharT, _Traits>::
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  	            {
517  	              _M_destroy_pback();
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
571  	    basic_filebuf<_CharT, _Traits>::
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
634  	    basic_filebuf<_CharT, _Traits>::
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  		    }
648  		  _M_destroy_pback();
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  		       // Set _M_reading. Buffer is already in initial 'read' mode.
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
722  	    basic_filebuf<_CharT, _Traits>::
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>
769  	    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
770  	    basic_filebuf<_CharT, _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
799  	    basic_filebuf<_CharT, _Traits>::
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)
821  		    _M_destroy_pback();
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
859  	    basic_filebuf<_CharT, _Traits>::
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.
866  		  _M_destroy_pback();
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
874  	    basic_filebuf<_CharT, _Traits>::
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>
899  	    int basic_filebuf<_CharT, _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
918  	    basic_filebuf<_CharT, _Traits>::
919  	    _M_terminate_output()
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
979  	    basic_filebuf<_CharT, _Traits>::
980  	    sync()
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
996  	    basic_filebuf<_CharT, _Traits>::
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().
1025 			      _M_ext_next = _M_ext_buf
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
1070