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 
43 namespace 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