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