1 // istream classes -*- C++ -*-
2 
3 // Copyright (C) 1997-2018 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::
sentry(basic_istream<_CharT,_Traits> & __in,bool __noskip)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>::
_M_extract(_ValueT & __v)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>::
operator >>(short & __n)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>::
operator >>(int & __n)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>::
operator >>(__streambuf_type * __sbout)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>::
get(void)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>::
get(char_type & __c)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>::
get(char_type * __s,streamsize __n,char_type __delim)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>::
get(__streambuf_type & __sb,char_type __delim)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>::
getline(char_type * __s,streamsize __n,char_type __delim)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>::
ignore(void)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>::
ignore(streamsize __n)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>::
ignore(streamsize __n,int_type __delim)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>::
peek(void)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>::
read(char_type * __s,streamsize __n)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>::
readsome(char_type * __s,streamsize __n)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>::
putback(char_type __c)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>::
unget(void)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>::
sync(void)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>::
tellg(void)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>::
seekg(pos_type __pos)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>::
seekg(off_type __off,ios_base::seekdir __dir)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>&
operator >>(basic_istream<_CharT,_Traits> & __in,_CharT & __c)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>&
operator >>(basic_istream<_CharT,_Traits> & __in,_CharT * __s)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>&
ws(basic_istream<_CharT,_Traits> & __in)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