1    	// istream classes -*- 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/istream.tcc
26   	 *  This is an internal header file, included by other library headers.
27   	 *  Do not attempt to use it directly. @headername{istream}
28   	 */
29   	
30   	//
31   	// ISO C++ 14882: 27.6.1  Input streams
32   	//
33   	
34   	#ifndef _ISTREAM_TCC
35   	#define _ISTREAM_TCC 1
36   	
37   	#pragma GCC system_header
38   	
39   	#include <bits/cxxabi_forced.h>
40   	
41   	namespace std _GLIBCXX_VISIBILITY(default)
42   	{
43   	_GLIBCXX_BEGIN_NAMESPACE_VERSION
44   	
45   	  template<typename _CharT, typename _Traits>
46   	    basic_istream<_CharT, _Traits>::sentry::
47   	    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
48   	    {
49   	      ios_base::iostate __err = ios_base::goodbit;
50   	      if (__in.good())
51   		__try
52   		  {
53   		    if (__in.tie())
54   		      __in.tie()->flush();
55   		    if (!__noskip && bool(__in.flags() & ios_base::skipws))
56   		      {
57   			const __int_type __eof = traits_type::eof();
58   			__streambuf_type* __sb = __in.rdbuf();
59   			__int_type __c = __sb->sgetc();
60   	
61   			const __ctype_type& __ct = __check_facet(__in._M_ctype);
62   			while (!traits_type::eq_int_type(__c, __eof)
63   			       && __ct.is(ctype_base::space,
64   					  traits_type::to_char_type(__c)))
65   			  __c = __sb->snextc();
66   	
67   			// _GLIBCXX_RESOLVE_LIB_DEFECTS
68   			// 195. Should basic_istream::sentry's constructor ever
69   			// set eofbit?
70   			if (traits_type::eq_int_type(__c, __eof))
71   			  __err |= ios_base::eofbit;
72   		      }
73   		  }
74   		__catch(__cxxabiv1::__forced_unwind&)
75   		  {
76   		    __in._M_setstate(ios_base::badbit);
77   		    __throw_exception_again;
78   		  }
79   		__catch(...)
80   		  { __in._M_setstate(ios_base::badbit); }
81   	
82   	      if (__in.good() && __err == ios_base::goodbit)
83   		_M_ok = true;
84   	      else
85   		{
86   		  __err |= ios_base::failbit;
87   		  __in.setstate(__err);
88   		}
89   	    }
90   	
91   	  template<typename _CharT, typename _Traits>
92   	    template<typename _ValueT>
93   	      basic_istream<_CharT, _Traits>&
94   	      basic_istream<_CharT, _Traits>::
95   	      _M_extract(_ValueT& __v)
96   	      {
97   		sentry __cerb(*this, false);
98   		if (__cerb)
99   		  {
100  		    ios_base::iostate __err = ios_base::goodbit;
101  		    __try
102  		      {
103  			const __num_get_type& __ng = __check_facet(this->_M_num_get);
104  			__ng.get(*this, 0, *this, __err, __v);
105  		      }
106  		    __catch(__cxxabiv1::__forced_unwind&)
107  		      {
108  			this->_M_setstate(ios_base::badbit);
109  			__throw_exception_again;
110  		      }
111  		    __catch(...)
112  		      { this->_M_setstate(ios_base::badbit); }
113  		    if (__err)
114  		      this->setstate(__err);
115  		  }
116  		return *this;
117  	      }
118  	
119  	  template<typename _CharT, typename _Traits>
120  	    basic_istream<_CharT, _Traits>&
121  	    basic_istream<_CharT, _Traits>::
122  	    operator>>(short& __n)
123  	    {
124  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
125  	      // 118. basic_istream uses nonexistent num_get member functions.
126  	      sentry __cerb(*this, false);
127  	      if (__cerb)
128  		{
129  		  ios_base::iostate __err = ios_base::goodbit;
130  		  __try
131  		    {
132  		      long __l;
133  		      const __num_get_type& __ng = __check_facet(this->_M_num_get);
134  		      __ng.get(*this, 0, *this, __err, __l);
135  	
136  		      // _GLIBCXX_RESOLVE_LIB_DEFECTS
137  		      // 696. istream::operator>>(int&) broken.
138  		      if (__l < __gnu_cxx::__numeric_traits<short>::__min)
139  			{
140  			  __err |= ios_base::failbit;
141  			  __n = __gnu_cxx::__numeric_traits<short>::__min;
142  			}
143  		      else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
144  			{
145  			  __err |= ios_base::failbit;
146  			  __n = __gnu_cxx::__numeric_traits<short>::__max;
147  			}
148  		      else
149  			__n = short(__l);
150  		    }
151  		  __catch(__cxxabiv1::__forced_unwind&)
152  		    {
153  		      this->_M_setstate(ios_base::badbit);
154  		      __throw_exception_again;
155  		    }
156  		  __catch(...)
157  		    { this->_M_setstate(ios_base::badbit); }
158  		  if (__err)
159  		    this->setstate(__err);
160  		}
161  	      return *this;
162  	    }
163  	
164  	  template<typename _CharT, typename _Traits>
165  	    basic_istream<_CharT, _Traits>&
166  	    basic_istream<_CharT, _Traits>::
167  	    operator>>(int& __n)
168  	    {
169  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
170  	      // 118. basic_istream uses nonexistent num_get member functions.
171  	      sentry __cerb(*this, false);
172  	      if (__cerb)
173  		{
174  		  ios_base::iostate __err = ios_base::goodbit;
175  		  __try
176  		    {
177  		      long __l;
178  		      const __num_get_type& __ng = __check_facet(this->_M_num_get);
179  		      __ng.get(*this, 0, *this, __err, __l);
180  	
181  		      // _GLIBCXX_RESOLVE_LIB_DEFECTS
182  		      // 696. istream::operator>>(int&) broken.
183  		      if (__l < __gnu_cxx::__numeric_traits<int>::__min)
184  			{
185  			  __err |= ios_base::failbit;
186  			  __n = __gnu_cxx::__numeric_traits<int>::__min;
187  			}
188  		      else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
189  			{
190  			  __err |= ios_base::failbit;	      
191  			  __n = __gnu_cxx::__numeric_traits<int>::__max;
192  			}
193  		      else
194  			__n = int(__l);
195  		    }
196  		  __catch(__cxxabiv1::__forced_unwind&)
197  		    {
198  		      this->_M_setstate(ios_base::badbit);
199  		      __throw_exception_again;
200  		    }
201  		  __catch(...)
202  		    { this->_M_setstate(ios_base::badbit); }
203  		  if (__err)
204  		    this->setstate(__err);
205  		}
206  	      return *this;
207  	    }
208  	
209  	  template<typename _CharT, typename _Traits>
210  	    basic_istream<_CharT, _Traits>&
211  	    basic_istream<_CharT, _Traits>::
212  	    operator>>(__streambuf_type* __sbout)
213  	    {
214  	      ios_base::iostate __err = ios_base::goodbit;
215  	      sentry __cerb(*this, false);
216  	      if (__cerb && __sbout)
217  		{
218  		  __try
219  		    {
220  		      bool __ineof;
221  		      if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
222  			__err |= ios_base::failbit;
223  		      if (__ineof)
224  			__err |= ios_base::eofbit;
225  		    }
226  		  __catch(__cxxabiv1::__forced_unwind&)
227  		    {
228  		      this->_M_setstate(ios_base::failbit);
229  		      __throw_exception_again;
230  		    }
231  		  __catch(...)
232  		    { this->_M_setstate(ios_base::failbit); }
233  		}
234  	      else if (!__sbout)
235  		__err |= ios_base::failbit;
236  	      if (__err)
237  		this->setstate(__err);
238  	      return *this;
239  	    }
240  	
241  	  template<typename _CharT, typename _Traits>
242  	    typename basic_istream<_CharT, _Traits>::int_type
243  	    basic_istream<_CharT, _Traits>::
244  	    get(void)
245  	    {
246  	      const int_type __eof = traits_type::eof();
247  	      int_type __c = __eof;
248  	      _M_gcount = 0;
249  	      ios_base::iostate __err = ios_base::goodbit;
250  	      sentry __cerb(*this, true);
251  	      if (__cerb)
252  		{
253  		  __try
254  		    {
255  		      __c = this->rdbuf()->sbumpc();
256  		      // 27.6.1.1 paragraph 3
257  		      if (!traits_type::eq_int_type(__c, __eof))
258  			_M_gcount = 1;
259  		      else
260  			__err |= ios_base::eofbit;
261  		    }
262  		  __catch(__cxxabiv1::__forced_unwind&)
263  		    {
264  		      this->_M_setstate(ios_base::badbit);
265  		      __throw_exception_again;
266  		    }
267  		  __catch(...)
268  		    { this->_M_setstate(ios_base::badbit); }
269  		}
270  	      if (!_M_gcount)
271  		__err |= ios_base::failbit;
272  	      if (__err)
273  		this->setstate(__err);
274  	      return __c;
275  	    }
276  	
277  	  template<typename _CharT, typename _Traits>
278  	    basic_istream<_CharT, _Traits>&
279  	    basic_istream<_CharT, _Traits>::
280  	    get(char_type& __c)
281  	    {
282  	      _M_gcount = 0;
283  	      ios_base::iostate __err = ios_base::goodbit;
284  	      sentry __cerb(*this, true);
285  	      if (__cerb)
286  		{
287  		  __try
288  		    {
289  		      const int_type __cb = this->rdbuf()->sbumpc();
290  		      // 27.6.1.1 paragraph 3
291  		      if (!traits_type::eq_int_type(__cb, traits_type::eof()))
292  			{
293  			  _M_gcount = 1;
294  			  __c = traits_type::to_char_type(__cb);
295  			}
296  		      else
297  			__err |= ios_base::eofbit;
298  		    }
299  		  __catch(__cxxabiv1::__forced_unwind&)
300  		    {
301  		      this->_M_setstate(ios_base::badbit);
302  		      __throw_exception_again;
303  		    }
304  		  __catch(...)
305  		    { this->_M_setstate(ios_base::badbit); }
306  		}
307  	      if (!_M_gcount)
308  		__err |= ios_base::failbit;
309  	      if (__err)
310  		this->setstate(__err);
311  	      return *this;
312  	    }
313  	
314  	  template<typename _CharT, typename _Traits>
315  	    basic_istream<_CharT, _Traits>&
316  	    basic_istream<_CharT, _Traits>::
317  	    get(char_type* __s, streamsize __n, char_type __delim)
318  	    {
319  	      _M_gcount = 0;
320  	      ios_base::iostate __err = ios_base::goodbit;
321  	      sentry __cerb(*this, true);
322  	      if (__cerb)
323  		{
324  		  __try
325  		    {
326  		      const int_type __idelim = traits_type::to_int_type(__delim);
327  		      const int_type __eof = traits_type::eof();
328  		      __streambuf_type* __sb = this->rdbuf();
329  		      int_type __c = __sb->sgetc();
330  	
331  		      while (_M_gcount + 1 < __n
332  			     && !traits_type::eq_int_type(__c, __eof)
333  			     && !traits_type::eq_int_type(__c, __idelim))
334  			{
335  			  *__s++ = traits_type::to_char_type(__c);
336  			  ++_M_gcount;
337  			  __c = __sb->snextc();
338  			}
339  		      if (traits_type::eq_int_type(__c, __eof))
340  			__err |= ios_base::eofbit;
341  		    }
342  		  __catch(__cxxabiv1::__forced_unwind&)
343  		    {
344  		      this->_M_setstate(ios_base::badbit);
345  		      __throw_exception_again;
346  		    }
347  		  __catch(...)
348  		    { this->_M_setstate(ios_base::badbit); }
349  		}
350  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
351  	      // 243. get and getline when sentry reports failure.
352  	      if (__n > 0)
353  		*__s = char_type();
354  	      if (!_M_gcount)
355  		__err |= ios_base::failbit;
356  	      if (__err)
357  		this->setstate(__err);
358  	      return *this;
359  	    }
360  	
361  	  template<typename _CharT, typename _Traits>
362  	    basic_istream<_CharT, _Traits>&
363  	    basic_istream<_CharT, _Traits>::
364  	    get(__streambuf_type& __sb, char_type __delim)
365  	    {
366  	      _M_gcount = 0;
367  	      ios_base::iostate __err = ios_base::goodbit;
368  	      sentry __cerb(*this, true);
369  	      if (__cerb)
370  		{
371  		  __try
372  		    {
373  		      const int_type __idelim = traits_type::to_int_type(__delim);
374  		      const int_type __eof = traits_type::eof();
375  		      __streambuf_type* __this_sb = this->rdbuf();
376  		      int_type __c = __this_sb->sgetc();
377  		      char_type __c2 = traits_type::to_char_type(__c);
378  	
379  		      while (!traits_type::eq_int_type(__c, __eof)
380  			     && !traits_type::eq_int_type(__c, __idelim)
381  			     && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
382  			{
383  			  ++_M_gcount;
384  			  __c = __this_sb->snextc();
385  			  __c2 = traits_type::to_char_type(__c);
386  			}
387  		      if (traits_type::eq_int_type(__c, __eof))
388  			__err |= ios_base::eofbit;
389  		    }
390  		  __catch(__cxxabiv1::__forced_unwind&)
391  		    {
392  		      this->_M_setstate(ios_base::badbit);
393  		      __throw_exception_again;
394  		    }
395  		  __catch(...)
396  		    { this->_M_setstate(ios_base::badbit); }
397  		}
398  	      if (!_M_gcount)
399  		__err |= ios_base::failbit;
400  	      if (__err)
401  		this->setstate(__err);
402  	      return *this;
403  	    }
404  	
405  	  template<typename _CharT, typename _Traits>
406  	    basic_istream<_CharT, _Traits>&
407  	    basic_istream<_CharT, _Traits>::
408  	    getline(char_type* __s, streamsize __n, char_type __delim)
409  	    {
410  	      _M_gcount = 0;
411  	      ios_base::iostate __err = ios_base::goodbit;
412  	      sentry __cerb(*this, true);
413  	      if (__cerb)
414  	        {
415  	          __try
416  	            {
417  	              const int_type __idelim = traits_type::to_int_type(__delim);
418  	              const int_type __eof = traits_type::eof();
419  	              __streambuf_type* __sb = this->rdbuf();
420  	              int_type __c = __sb->sgetc();
421  	
422  	              while (_M_gcount + 1 < __n
423  	                     && !traits_type::eq_int_type(__c, __eof)
424  	                     && !traits_type::eq_int_type(__c, __idelim))
425  	                {
426  	                  *__s++ = traits_type::to_char_type(__c);
427  	                  __c = __sb->snextc();
428  	                  ++_M_gcount;
429  	                }
430  	              if (traits_type::eq_int_type(__c, __eof))
431  	                __err |= ios_base::eofbit;
432  	              else
433  	                {
434  	                  if (traits_type::eq_int_type(__c, __idelim))
435  	                    {
436  	                      __sb->sbumpc();
437  	                      ++_M_gcount;
438  	                    }
439  	                  else
440  	                    __err |= ios_base::failbit;
441  	                }
442  	            }
443  		  __catch(__cxxabiv1::__forced_unwind&)
444  		    {
445  		      this->_M_setstate(ios_base::badbit);
446  		      __throw_exception_again;
447  		    }
448  	          __catch(...)
449  	            { this->_M_setstate(ios_base::badbit); }
450  	        }
451  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
452  	      // 243. get and getline when sentry reports failure.
453  	      if (__n > 0)
454  		*__s = char_type();
455  	      if (!_M_gcount)
456  	        __err |= ios_base::failbit;
457  	      if (__err)
458  	        this->setstate(__err);
459  	      return *this;
460  	    }
461  	
462  	  // We provide three overloads, since the first two are much simpler
463  	  // than the general case. Also, the latter two can thus adopt the
464  	  // same "batchy" strategy used by getline above.
465  	  template<typename _CharT, typename _Traits>
466  	    basic_istream<_CharT, _Traits>&
467  	    basic_istream<_CharT, _Traits>::
468  	    ignore(void)
469  	    {
470  	      _M_gcount = 0;
471  	      sentry __cerb(*this, true);
472  	      if (__cerb)
473  		{
474  		  ios_base::iostate __err = ios_base::goodbit;
475  		  __try
476  		    {
477  		      const int_type __eof = traits_type::eof();
478  		      __streambuf_type* __sb = this->rdbuf();
479  	
480  		      if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
481  			__err |= ios_base::eofbit;
482  		      else
483  			_M_gcount = 1;
484  		    }
485  		  __catch(__cxxabiv1::__forced_unwind&)
486  		    {
487  		      this->_M_setstate(ios_base::badbit);
488  		      __throw_exception_again;
489  		    }
490  		  __catch(...)
491  		    { this->_M_setstate(ios_base::badbit); }
492  		  if (__err)
493  		    this->setstate(__err);
494  		}
495  	      return *this;
496  	    }
497  	
498  	  template<typename _CharT, typename _Traits>
499  	    basic_istream<_CharT, _Traits>&
500  	    basic_istream<_CharT, _Traits>::
501  	    ignore(streamsize __n)
502  	    {
503  	      _M_gcount = 0;
504  	      sentry __cerb(*this, true);
505  	      if (__cerb && __n > 0)
506  	        {
507  	          ios_base::iostate __err = ios_base::goodbit;
508  	          __try
509  	            {
510  	              const int_type __eof = traits_type::eof();
511  	              __streambuf_type* __sb = this->rdbuf();
512  	              int_type __c = __sb->sgetc();
513  	
514  		      // N.B. On LFS-enabled platforms streamsize is still 32 bits
515  		      // wide: if we want to implement the standard mandated behavior
516  		      // for n == max() (see 27.6.1.3/24) we are at risk of signed
517  		      // integer overflow: thus these contortions. Also note that,
518  		      // by definition, when more than 2G chars are actually ignored,
519  		      // _M_gcount (the return value of gcount, that is) cannot be
520  		      // really correct, being unavoidably too small.
521  		      bool __large_ignore = false;
522  		      while (true)
523  			{
524  			  while (_M_gcount < __n
525  				 && !traits_type::eq_int_type(__c, __eof))
526  			    {
527  			      ++_M_gcount;
528  			      __c = __sb->snextc();
529  			    }
530  			  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
531  			      && !traits_type::eq_int_type(__c, __eof))
532  			    {
533  			      _M_gcount =
534  				__gnu_cxx::__numeric_traits<streamsize>::__min;
535  			      __large_ignore = true;
536  			    }
537  			  else
538  			    break;
539  			}
540  	
541  		      if (__large_ignore)
542  			_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
543  	
544  		      if (traits_type::eq_int_type(__c, __eof))
545  	                __err |= ios_base::eofbit;
546  	            }
547  		  __catch(__cxxabiv1::__forced_unwind&)
548  		    {
549  		      this->_M_setstate(ios_base::badbit);
550  		      __throw_exception_again;
551  		    }
552  	          __catch(...)
553  	            { this->_M_setstate(ios_base::badbit); }
554  	          if (__err)
555  	            this->setstate(__err);
556  	        }
557  	      return *this;
558  	    }
559  	
560  	  template<typename _CharT, typename _Traits>
561  	    basic_istream<_CharT, _Traits>&
562  	    basic_istream<_CharT, _Traits>::
563  	    ignore(streamsize __n, int_type __delim)
564  	    {
565  	      _M_gcount = 0;
566  	      sentry __cerb(*this, true);
567  	      if (__cerb && __n > 0)
568  	        {
569  	          ios_base::iostate __err = ios_base::goodbit;
570  	          __try
571  	            {
572  	              const int_type __eof = traits_type::eof();
573  	              __streambuf_type* __sb = this->rdbuf();
574  	              int_type __c = __sb->sgetc();
575  	
576  		      // See comment above.
577  		      bool __large_ignore = false;
578  		      while (true)
579  			{
580  			  while (_M_gcount < __n
581  				 && !traits_type::eq_int_type(__c, __eof)
582  				 && !traits_type::eq_int_type(__c, __delim))
583  			    {
584  			      ++_M_gcount;
585  			      __c = __sb->snextc();
586  			    }
587  			  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
588  			      && !traits_type::eq_int_type(__c, __eof)
589  			      && !traits_type::eq_int_type(__c, __delim))
590  			    {
591  			      _M_gcount =
592  				__gnu_cxx::__numeric_traits<streamsize>::__min;
593  			      __large_ignore = true;
594  			    }
595  			  else
596  			    break;
597  			}
598  	
599  		      if (__large_ignore)
600  			_M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
601  	
602  	              if (traits_type::eq_int_type(__c, __eof))
603  	                __err |= ios_base::eofbit;
604  		      else if (traits_type::eq_int_type(__c, __delim))
605  			{
606  			  if (_M_gcount
607  			      < __gnu_cxx::__numeric_traits<streamsize>::__max)
608  			    ++_M_gcount;
609  			  __sb->sbumpc();
610  			}
611  	            }
612  		  __catch(__cxxabiv1::__forced_unwind&)
613  		    {
614  		      this->_M_setstate(ios_base::badbit);
615  		      __throw_exception_again;
616  		    }
617  	          __catch(...)
618  	            { this->_M_setstate(ios_base::badbit); }
619  	          if (__err)
620  	            this->setstate(__err);
621  	        }
622  	      return *this;
623  	    }
624  	
625  	  template<typename _CharT, typename _Traits>
626  	    typename basic_istream<_CharT, _Traits>::int_type
627  	    basic_istream<_CharT, _Traits>::
628  	    peek(void)
629  	    {
630  	      int_type __c = traits_type::eof();
631  	      _M_gcount = 0;
632  	      sentry __cerb(*this, true);
633  	      if (__cerb)
634  		{
635  		  ios_base::iostate __err = ios_base::goodbit;
636  		  __try
637  		    {
638  		      __c = this->rdbuf()->sgetc();
639  		      if (traits_type::eq_int_type(__c, traits_type::eof()))
640  			__err |= ios_base::eofbit;
641  		    }
642  		  __catch(__cxxabiv1::__forced_unwind&)
643  		    {
644  		      this->_M_setstate(ios_base::badbit);
645  		      __throw_exception_again;
646  		    }
647  		  __catch(...)
648  		    { this->_M_setstate(ios_base::badbit); }
649  		  if (__err)
650  		    this->setstate(__err);
651  		}
652  	      return __c;
653  	    }
654  	
655  	  template<typename _CharT, typename _Traits>
656  	    basic_istream<_CharT, _Traits>&
657  	    basic_istream<_CharT, _Traits>::
658  	    read(char_type* __s, streamsize __n)
659  	    {
660  	      _M_gcount = 0;
661  	      sentry __cerb(*this, true);
662  	      if (__cerb)
663  		{
664  		  ios_base::iostate __err = ios_base::goodbit;
665  		  __try
666  		    {
667  		      _M_gcount = this->rdbuf()->sgetn(__s, __n);
668  		      if (_M_gcount != __n)
669  			__err |= (ios_base::eofbit | ios_base::failbit);
670  		    }
671  		  __catch(__cxxabiv1::__forced_unwind&)
672  		    {
673  		      this->_M_setstate(ios_base::badbit);
674  		      __throw_exception_again;
675  		    }
676  		  __catch(...)
677  		    { this->_M_setstate(ios_base::badbit); }
678  		  if (__err)
679  		    this->setstate(__err);
680  		}
681  	      return *this;
682  	    }
683  	
684  	  template<typename _CharT, typename _Traits>
685  	    streamsize
686  	    basic_istream<_CharT, _Traits>::
687  	    readsome(char_type* __s, streamsize __n)
688  	    {
689  	      _M_gcount = 0;
690  	      sentry __cerb(*this, true);
691  	      if (__cerb)
692  		{
693  		  ios_base::iostate __err = ios_base::goodbit;
694  		  __try
695  		    {
696  		      // Cannot compare int_type with streamsize generically.
697  		      const streamsize __num = this->rdbuf()->in_avail();
698  		      if (__num > 0)
699  			_M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
700  		      else if (__num == -1)
701  			__err |= ios_base::eofbit;
702  		    }
703  		  __catch(__cxxabiv1::__forced_unwind&)
704  		    {
705  		      this->_M_setstate(ios_base::badbit);
706  		      __throw_exception_again;
707  		    }
708  		  __catch(...)
709  		    { this->_M_setstate(ios_base::badbit); }
710  		  if (__err)
711  		    this->setstate(__err);
712  		}
713  	      return _M_gcount;
714  	    }
715  	
716  	  template<typename _CharT, typename _Traits>
717  	    basic_istream<_CharT, _Traits>&
718  	    basic_istream<_CharT, _Traits>::
719  	    putback(char_type __c)
720  	    {
721  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
722  	      // 60. What is a formatted input function?
723  	      _M_gcount = 0;
724  	      // Clear eofbit per N3168.
725  	      this->clear(this->rdstate() & ~ios_base::eofbit);
726  	      sentry __cerb(*this, true);
727  	      if (__cerb)
728  		{
729  		  ios_base::iostate __err = ios_base::goodbit;
730  		  __try
731  		    {
732  		      const int_type __eof = traits_type::eof();
733  		      __streambuf_type* __sb = this->rdbuf();
734  		      if (!__sb
735  			  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
736  			__err |= ios_base::badbit;
737  		    }
738  		  __catch(__cxxabiv1::__forced_unwind&)
739  		    {
740  		      this->_M_setstate(ios_base::badbit);
741  		      __throw_exception_again;
742  		    }
743  		  __catch(...)
744  		    { this->_M_setstate(ios_base::badbit); }
745  		  if (__err)
746  		    this->setstate(__err);
747  		}
748  	      return *this;
749  	    }
750  	
751  	  template<typename _CharT, typename _Traits>
752  	    basic_istream<_CharT, _Traits>&
753  	    basic_istream<_CharT, _Traits>::
754  	    unget(void)
755  	    {
756  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
757  	      // 60. What is a formatted input function?
758  	      _M_gcount = 0;
759  	      // Clear eofbit per N3168.
760  	      this->clear(this->rdstate() & ~ios_base::eofbit);
761  	      sentry __cerb(*this, true);
762  	      if (__cerb)
763  		{
764  		  ios_base::iostate __err = ios_base::goodbit;
765  		  __try
766  		    {
767  		      const int_type __eof = traits_type::eof();
768  		      __streambuf_type* __sb = this->rdbuf();
769  		      if (!__sb
770  			  || traits_type::eq_int_type(__sb->sungetc(), __eof))
771  			__err |= ios_base::badbit;
772  		    }
773  		  __catch(__cxxabiv1::__forced_unwind&)
774  		    {
775  		      this->_M_setstate(ios_base::badbit);
776  		      __throw_exception_again;
777  		    }
778  		  __catch(...)
779  		    { this->_M_setstate(ios_base::badbit); }
780  		  if (__err)
781  		    this->setstate(__err);
782  		}
783  	      return *this;
784  	    }
785  	
786  	  template<typename _CharT, typename _Traits>
787  	    int
788  	    basic_istream<_CharT, _Traits>::
789  	    sync(void)
790  	    {
791  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
792  	      // DR60.  Do not change _M_gcount.
793  	      int __ret = -1;
794  	      sentry __cerb(*this, true);
795  	      if (__cerb)
796  		{
797  		  ios_base::iostate __err = ios_base::goodbit;
798  		  __try
799  		    {
800  		      __streambuf_type* __sb = this->rdbuf();
801  		      if (__sb)
802  			{
803  			  if (__sb->pubsync() == -1)
804  			    __err |= ios_base::badbit;
805  			  else
806  			    __ret = 0;
807  			}
808  		    }
809  		  __catch(__cxxabiv1::__forced_unwind&)
810  		    {
811  		      this->_M_setstate(ios_base::badbit);
812  		      __throw_exception_again;
813  		    }
814  		  __catch(...)
815  		    { this->_M_setstate(ios_base::badbit); }
816  		  if (__err)
817  		    this->setstate(__err);
818  		}
819  	      return __ret;
820  	    }
821  	
822  	  template<typename _CharT, typename _Traits>
823  	    typename basic_istream<_CharT, _Traits>::pos_type
824  	    basic_istream<_CharT, _Traits>::
825  	    tellg(void)
826  	    {
827  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
828  	      // DR60.  Do not change _M_gcount.
829  	      pos_type __ret = pos_type(-1);
830  	      sentry __cerb(*this, true);
831  	      if (__cerb)
832  		{
833  		  __try
834  		    {
835  		      if (!this->fail())
836  			__ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
837  							  ios_base::in);
838  		    }
839  		  __catch(__cxxabiv1::__forced_unwind&)
840  		    {
841  		      this->_M_setstate(ios_base::badbit);
842  		      __throw_exception_again;
843  		    }
844  		  __catch(...)
845  		    { this->_M_setstate(ios_base::badbit); }
846  		}
847  	      return __ret;
848  	    }
849  	
850  	  template<typename _CharT, typename _Traits>
851  	    basic_istream<_CharT, _Traits>&
852  	    basic_istream<_CharT, _Traits>::
853  	    seekg(pos_type __pos)
854  	    {
855  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
856  	      // DR60.  Do not change _M_gcount.
857  	      // Clear eofbit per N3168.
858  	      this->clear(this->rdstate() & ~ios_base::eofbit);
859  	      sentry __cerb(*this, true);
860  	      if (__cerb)
861  		{
862  		  ios_base::iostate __err = ios_base::goodbit;
863  		  __try
864  		    {
865  		      if (!this->fail())
866  			{
867  			  // 136.  seekp, seekg setting wrong streams?
868  			  const pos_type __p = this->rdbuf()->pubseekpos(__pos,
869  									 ios_base::in);
870  			  
871  			  // 129.  Need error indication from seekp() and seekg()
872  			  if (__p == pos_type(off_type(-1)))
873  			    __err |= ios_base::failbit;
874  			}
875  		    }
876  		  __catch(__cxxabiv1::__forced_unwind&)
877  		    {
878  		      this->_M_setstate(ios_base::badbit);
879  		      __throw_exception_again;
880  		    }
881  		  __catch(...)
882  		    { this->_M_setstate(ios_base::badbit); }
883  		  if (__err)
884  		    this->setstate(__err);
885  		}
886  	      return *this;
887  	    }
888  	
889  	  template<typename _CharT, typename _Traits>
890  	    basic_istream<_CharT, _Traits>&
891  	    basic_istream<_CharT, _Traits>::
892  	    seekg(off_type __off, ios_base::seekdir __dir)
893  	    {
894  	      // _GLIBCXX_RESOLVE_LIB_DEFECTS
895  	      // DR60.  Do not change _M_gcount.
896  	      // Clear eofbit per N3168.
897  	      this->clear(this->rdstate() & ~ios_base::eofbit);
898  	      sentry __cerb(*this, true);
899  	      if (__cerb)
900  		{
901  		  ios_base::iostate __err = ios_base::goodbit;
902  		  __try
903  		    {
904  		      if (!this->fail())
905  			{
906  			  // 136.  seekp, seekg setting wrong streams?
907  			  const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
908  									 ios_base::in);
909  		      
910  			  // 129.  Need error indication from seekp() and seekg()
911  			  if (__p == pos_type(off_type(-1)))
912  			    __err |= ios_base::failbit;
913  			}
914  		    }
915  		  __catch(__cxxabiv1::__forced_unwind&)
916  		    {
917  		      this->_M_setstate(ios_base::badbit);
918  		      __throw_exception_again;
919  		    }
920  		  __catch(...)
921  		    { this->_M_setstate(ios_base::badbit); }
922  		  if (__err)
923  		    this->setstate(__err);
924  		}
925  	      return *this;
926  	    }
927  	
928  	  // 27.6.1.2.3 Character extraction templates
929  	  template<typename _CharT, typename _Traits>
930  	    basic_istream<_CharT, _Traits>&
931  	    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
932  	    {
933  	      typedef basic_istream<_CharT, _Traits>		__istream_type;
934  	      typedef typename __istream_type::int_type         __int_type;
935  	
936  	      typename __istream_type::sentry __cerb(__in, false);
937  	      if (__cerb)
938  		{
939  		  ios_base::iostate __err = ios_base::goodbit;
940  		  __try
941  		    {
942  		      const __int_type __cb = __in.rdbuf()->sbumpc();
943  		      if (!_Traits::eq_int_type(__cb, _Traits::eof()))
944  			__c = _Traits::to_char_type(__cb);
945  		      else
946  			__err |= (ios_base::eofbit | ios_base::failbit);
947  		    }
948  		  __catch(__cxxabiv1::__forced_unwind&)
949  		    {
950  		      __in._M_setstate(ios_base::badbit);
951  		      __throw_exception_again;
952  		    }
953  		  __catch(...)
954  		    { __in._M_setstate(ios_base::badbit); }
955  		  if (__err)
956  		    __in.setstate(__err);
957  		}
958  	      return __in;
959  	    }
960  	
961  	  template<typename _CharT, typename _Traits>
962  	    basic_istream<_CharT, _Traits>&
963  	    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
964  	    {
965  	      typedef basic_istream<_CharT, _Traits>		__istream_type;
966  	      typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
967  	      typedef typename _Traits::int_type		int_type;
968  	      typedef _CharT					char_type;
969  	      typedef ctype<_CharT>				__ctype_type;
970  	
971  	      streamsize __extracted = 0;
972  	      ios_base::iostate __err = ios_base::goodbit;
973  	      typename __istream_type::sentry __cerb(__in, false);
974  	      if (__cerb)
975  		{
976  		  __try
977  		    {
978  		      // Figure out how many characters to extract.
979  		      streamsize __num = __in.width();
980  		      if (__num <= 0)
981  			__num = __gnu_cxx::__numeric_traits<streamsize>::__max;
982  	
983  		      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
984  	
985  		      const int_type __eof = _Traits::eof();
986  		      __streambuf_type* __sb = __in.rdbuf();
987  		      int_type __c = __sb->sgetc();
988  	
989  		      while (__extracted < __num - 1
990  			     && !_Traits::eq_int_type(__c, __eof)
991  			     && !__ct.is(ctype_base::space,
992  					 _Traits::to_char_type(__c)))
993  			{
994  			  *__s++ = _Traits::to_char_type(__c);
995  			  ++__extracted;
996  			  __c = __sb->snextc();
997  			}
998  		      if (_Traits::eq_int_type(__c, __eof))
999  			__err |= ios_base::eofbit;
1000 	
1001 		      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1002 		      // 68.  Extractors for char* should store null at end
1003 		      *__s = char_type();
1004 		      __in.width(0);
1005 		    }
1006 		  __catch(__cxxabiv1::__forced_unwind&)
1007 		    {
1008 		      __in._M_setstate(ios_base::badbit);
1009 		      __throw_exception_again;
1010 		    }
1011 		  __catch(...)
1012 		    { __in._M_setstate(ios_base::badbit); }
1013 		}
1014 	      if (!__extracted)
1015 		__err |= ios_base::failbit;
1016 	      if (__err)
1017 		__in.setstate(__err);
1018 	      return __in;
1019 	    }
1020 	
1021 	  // 27.6.1.4 Standard basic_istream manipulators
1022 	  template<typename _CharT, typename _Traits>
1023 	    basic_istream<_CharT, _Traits>&
1024 	    ws(basic_istream<_CharT, _Traits>& __in)
1025 	    {
1026 	      typedef basic_istream<_CharT, _Traits>		__istream_type;
1027 	      typedef basic_streambuf<_CharT, _Traits>          __streambuf_type;
1028 	      typedef typename __istream_type::int_type		__int_type;
1029 	      typedef ctype<_CharT>				__ctype_type;
1030 	
1031 	      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1032 	      const __int_type __eof = _Traits::eof();
1033 	      __streambuf_type* __sb = __in.rdbuf();
1034 	      __int_type __c = __sb->sgetc();
1035 	
1036 	      while (!_Traits::eq_int_type(__c, __eof)
1037 		     && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1038 		__c = __sb->snextc();
1039 	
1040 	       if (_Traits::eq_int_type(__c, __eof))
1041 		 __in.setstate(ios_base::eofbit);
1042 	      return __in;
1043 	    }
1044 	
1045 	  // Inhibit implicit instantiations for required instantiations,
1046 	  // which are defined via explicit instantiations elsewhere.
1047 	#if _GLIBCXX_EXTERN_TEMPLATE
1048 	  extern template class basic_istream<char>;
1049 	  extern template istream& ws(istream&);
1050 	  extern template istream& operator>>(istream&, char&);
1051 	  extern template istream& operator>>(istream&, char*);
1052 	  extern template istream& operator>>(istream&, unsigned char&);
1053 	  extern template istream& operator>>(istream&, signed char&);
1054 	  extern template istream& operator>>(istream&, unsigned char*);
1055 	  extern template istream& operator>>(istream&, signed char*);
1056 	
1057 	  extern template istream& istream::_M_extract(unsigned short&);
1058 	  extern template istream& istream::_M_extract(unsigned int&);  
1059 	  extern template istream& istream::_M_extract(long&);
1060 	  extern template istream& istream::_M_extract(unsigned long&);
1061 	  extern template istream& istream::_M_extract(bool&);
1062 	#ifdef _GLIBCXX_USE_LONG_LONG
1063 	  extern template istream& istream::_M_extract(long long&);
1064 	  extern template istream& istream::_M_extract(unsigned long long&);
1065 	#endif
1066 	  extern template istream& istream::_M_extract(float&);
1067 	  extern template istream& istream::_M_extract(double&);
1068 	  extern template istream& istream::_M_extract(long double&);
1069 	  extern template istream& istream::_M_extract(void*&);
1070 	
1071 	  extern template class basic_iostream<char>;
1072 	
1073 	#ifdef _GLIBCXX_USE_WCHAR_T
1074 	  extern template class basic_istream<wchar_t>;
1075 	  extern template wistream& ws(wistream&);
1076 	  extern template wistream& operator>>(wistream&, wchar_t&);
1077 	  extern template wistream& operator>>(wistream&, wchar_t*);
1078 	
1079 	  extern template wistream& wistream::_M_extract(unsigned short&);
1080 	  extern template wistream& wistream::_M_extract(unsigned int&);  
1081 	  extern template wistream& wistream::_M_extract(long&);
1082 	  extern template wistream& wistream::_M_extract(unsigned long&);
1083 	  extern template wistream& wistream::_M_extract(bool&);
1084 	#ifdef _GLIBCXX_USE_LONG_LONG
1085 	  extern template wistream& wistream::_M_extract(long long&);
1086 	  extern template wistream& wistream::_M_extract(unsigned long long&);
1087 	#endif
1088 	  extern template wistream& wistream::_M_extract(float&);
1089 	  extern template wistream& wistream::_M_extract(double&);
1090 	  extern template wistream& wistream::_M_extract(long double&);
1091 	  extern template wistream& wistream::_M_extract(void*&);
1092 	
1093 	  extern template class basic_iostream<wchar_t>;
1094 	#endif
1095 	#endif
1096 	
1097 	_GLIBCXX_END_NAMESPACE_VERSION
1098 	} // namespace std
1099 	
1100 	#endif
1101