istream.tcc revision 117397
1// istream classes -*- C++ -*-
2
3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
4// Free Software Foundation, Inc.
5//
6// This file is part of the GNU ISO C++ Library.  This library is free
7// software; you can redistribute it and/or modify it under the
8// terms of the GNU General Public License as published by the
9// Free Software Foundation; either version 2, or (at your option)
10// any later version.
11
12// This library is distributed in the hope that it will be useful,
13// but WITHOUT ANY WARRANTY; without even the implied warranty of
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15// GNU General Public License for more details.
16
17// You should have received a copy of the GNU General Public License along
18// with this library; see the file COPYING.  If not, write to the Free
19// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20// USA.
21
22// As a special exception, you may use this file as part of a free software
23// library without restriction.  Specifically, if other files instantiate
24// templates or use macros or inline functions from this file, or you compile
25// this file and link it with other files to produce an executable, this
26// file does not by itself cause the resulting executable to be covered by
27// the GNU General Public License.  This exception does not however
28// invalidate any other reasons why the executable file might be covered by
29// the GNU General Public License.
30
31//
32// ISO C++ 14882: 27.6.2  Output streams
33//
34
35#pragma GCC system_header
36
37#include <locale>
38#include <ostream> // For flush()
39
40namespace std 
41{
42  template<typename _CharT, typename _Traits>
43    basic_istream<_CharT, _Traits>::sentry::
44    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
45    {
46      if (__in.good()) 
47	{
48	  if (__in.tie())
49	    __in.tie()->flush();
50	  if (!__noskipws && (__in.flags() & ios_base::skipws))
51	    {	  
52	      const __int_type __eof = traits_type::eof();
53	      __streambuf_type* __sb = __in.rdbuf();
54	      __int_type __c = __sb->sgetc();
55
56	      if (__in._M_check_facet(__in._M_fctype))
57		while (!traits_type::eq_int_type(__c, __eof)
58		       && __in._M_fctype->is(ctype_base::space, 
59					     traits_type::to_char_type(__c)))
60		  __c = __sb->snextc();
61
62#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
63//195.  Should basic_istream::sentry's constructor ever set eofbit? 
64	      if (traits_type::eq_int_type(__c, __eof))
65		__in.setstate(ios_base::eofbit);
66#endif
67	    }
68	}
69
70      if (__in.good())
71	_M_ok = true;
72      else
73	{
74	  _M_ok = false;
75	  __in.setstate(ios_base::failbit);
76	}
77    }
78
79  template<typename _CharT, typename _Traits>
80    basic_istream<_CharT, _Traits>& 
81    basic_istream<_CharT, _Traits>::
82    operator>>(__istream_type& (*__pf)(__istream_type&))
83    {
84      __pf(*this);
85      return *this;
86    }
87
88  template<typename _CharT, typename _Traits>
89    basic_istream<_CharT, _Traits>& 
90    basic_istream<_CharT, _Traits>::
91    operator>>(__ios_type& (*__pf)(__ios_type&))
92    {
93      __pf(*this);
94      return *this;
95    }
96  
97  template<typename _CharT, typename _Traits>
98    basic_istream<_CharT, _Traits>& 
99    basic_istream<_CharT, _Traits>::
100    operator>>(ios_base& (*__pf)(ios_base&))
101    {
102      __pf(*this);
103      return *this;
104    }
105  
106  template<typename _CharT, typename _Traits>
107    basic_istream<_CharT, _Traits>& 
108    basic_istream<_CharT, _Traits>::
109    operator>>(bool& __n)
110    {
111      sentry __cerb(*this, false);
112      if (__cerb) 
113	{
114	  try 
115	    {
116	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
117	      if (_M_check_facet(_M_fnumget))
118		_M_fnumget->get(*this, 0, *this, __err, __n);
119	      this->setstate(__err);
120	    }
121	  catch(...)
122	    {
123	      // 27.6.1.2.1 Common requirements.
124	      // Turn this on without causing an ios::failure to be thrown.
125	      this->_M_setstate(ios_base::badbit);
126	      if ((this->exceptions() & ios_base::badbit) != 0)
127		__throw_exception_again;
128	    }
129	}
130      return *this;
131    }
132
133  template<typename _CharT, typename _Traits>
134    basic_istream<_CharT, _Traits>& 
135    basic_istream<_CharT, _Traits>::
136    operator>>(short& __n)
137    {
138      sentry __cerb(*this, false);
139      if (__cerb) 
140	{
141	  try 
142	    {
143	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
144	      long __l;
145	      if (_M_check_facet(_M_fnumget))
146		_M_fnumget->get(*this, 0, *this, __err, __l);
147#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
148	      // 118. basic_istream uses nonexistent num_get member functions.
149	      if (!(__err & ios_base::failbit)
150		  && (numeric_limits<short>::min() <= __l 
151		      && __l <= numeric_limits<short>::max()))
152		__n = __l;
153	      else
154                __err |= ios_base::failbit;
155#endif
156	      this->setstate(__err);
157	    }
158	  catch(...)
159	    {
160	      // 27.6.1.2.1 Common requirements.
161	      // Turn this on without causing an ios::failure to be thrown.
162	      this->_M_setstate(ios_base::badbit);
163	      if ((this->exceptions() & ios_base::badbit) != 0)
164		__throw_exception_again;
165	    }
166	}
167      return *this;
168    }
169
170  template<typename _CharT, typename _Traits>
171    basic_istream<_CharT, _Traits>& 
172    basic_istream<_CharT, _Traits>::
173    operator>>(unsigned short& __n)
174    {
175      sentry __cerb(*this, false);
176      if (__cerb) 
177	{
178	  try 
179	    {
180	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
181	      if (_M_check_facet(_M_fnumget))
182		_M_fnumget->get(*this, 0, *this, __err, __n);
183	      this->setstate(__err);
184	    }
185	  catch(...)
186	    {
187	      // 27.6.1.2.1 Common requirements.
188	      // Turn this on without causing an ios::failure to be thrown.
189	      this->_M_setstate(ios_base::badbit);
190	      if ((this->exceptions() & ios_base::badbit) != 0)
191		__throw_exception_again;
192	    }
193	}
194      return *this;
195    }
196
197  template<typename _CharT, typename _Traits>
198    basic_istream<_CharT, _Traits>& 
199    basic_istream<_CharT, _Traits>::
200    operator>>(int& __n)
201    {
202      sentry __cerb(*this, false);
203      if (__cerb) 
204	{
205	  try 
206	    {
207	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
208	      long __l;
209	      if (_M_check_facet(_M_fnumget))
210		_M_fnumget->get(*this, 0, *this, __err, __l);
211#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
212	      // 118. basic_istream uses nonexistent num_get member functions.
213	      if (!(__err & ios_base::failbit)
214		  && (numeric_limits<int>::min() <= __l 
215		      && __l <= numeric_limits<int>::max()))
216		__n = __l;
217	      else
218                __err |= ios_base::failbit;
219#endif
220	      this->setstate(__err);
221	    }
222	  catch(...)
223	    {
224	      // 27.6.1.2.1 Common requirements.
225	      // Turn this on without causing an ios::failure to be thrown.
226	      this->_M_setstate(ios_base::badbit);
227	      if ((this->exceptions() & ios_base::badbit) != 0)
228		__throw_exception_again;
229	    }
230	}
231      return *this;
232    }
233
234  template<typename _CharT, typename _Traits>
235    basic_istream<_CharT, _Traits>& 
236    basic_istream<_CharT, _Traits>::
237    operator>>(unsigned int& __n)
238    {
239      sentry __cerb(*this, false);
240      if (__cerb) 
241	{
242	  try 
243	    {
244	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
245	      if (_M_check_facet(_M_fnumget))
246		_M_fnumget->get(*this, 0, *this, __err, __n);
247	      this->setstate(__err);
248	    }
249	  catch(...)
250	    {
251	      // 27.6.1.2.1 Common requirements.
252	      // Turn this on without causing an ios::failure to be thrown.
253	      this->_M_setstate(ios_base::badbit);
254	      if ((this->exceptions() & ios_base::badbit) != 0)
255		__throw_exception_again;
256	    }
257	}
258      return *this;
259    }
260
261  template<typename _CharT, typename _Traits>
262    basic_istream<_CharT, _Traits>& 
263    basic_istream<_CharT, _Traits>::
264    operator>>(long& __n)
265    {
266      sentry __cerb(*this, false);
267      if (__cerb) 
268	{
269	  try 
270	    {
271	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
272	      if (_M_check_facet(_M_fnumget))
273		_M_fnumget->get(*this, 0, *this, __err, __n);
274	      this->setstate(__err);
275	    }
276	  catch(...)
277	    {
278	      // 27.6.1.2.1 Common requirements.
279	      // Turn this on without causing an ios::failure to be thrown.
280	      this->_M_setstate(ios_base::badbit);
281	      if ((this->exceptions() & ios_base::badbit) != 0)
282		__throw_exception_again;
283	    }
284	}
285      return *this;
286    }
287
288  template<typename _CharT, typename _Traits>
289    basic_istream<_CharT, _Traits>& 
290    basic_istream<_CharT, _Traits>::
291    operator>>(unsigned long& __n)
292    {
293      sentry __cerb(*this, false);
294      if (__cerb) 
295	{
296	  try 
297	    {
298	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
299	      if (_M_check_facet(_M_fnumget))
300		_M_fnumget->get(*this, 0, *this, __err, __n);
301	      this->setstate(__err);
302	    }
303	  catch(...)
304	    {
305	      // 27.6.1.2.1 Common requirements.
306	      // Turn this on without causing an ios::failure to be thrown.
307	      this->_M_setstate(ios_base::badbit);
308	      if ((this->exceptions() & ios_base::badbit) != 0)
309		__throw_exception_again;
310	    }
311	}
312      return *this;
313    }
314
315#ifdef _GLIBCPP_USE_LONG_LONG
316  template<typename _CharT, typename _Traits>
317    basic_istream<_CharT, _Traits>& 
318    basic_istream<_CharT, _Traits>::
319    operator>>(long long& __n)
320    {
321      sentry __cerb(*this, false);
322      if (__cerb) 
323	{
324	  try 
325	    {
326	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
327	      if (_M_check_facet(_M_fnumget))
328		_M_fnumget->get(*this, 0, *this, __err, __n);
329	      this->setstate(__err);
330	    }
331	  catch(...)
332	    {
333	      // 27.6.1.2.1 Common requirements.
334	      // Turn this on without causing an ios::failure to be thrown.
335	      this->_M_setstate(ios_base::badbit);
336	      if ((this->exceptions() & ios_base::badbit) != 0)
337	      __throw_exception_again;
338	    }
339	}
340      return *this;
341    }
342
343  template<typename _CharT, typename _Traits>
344    basic_istream<_CharT, _Traits>& 
345    basic_istream<_CharT, _Traits>::
346    operator>>(unsigned long long& __n)
347    {
348      sentry __cerb(*this, false);
349      if (__cerb) 
350	{
351	  try 
352	    {
353	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
354	      if (_M_check_facet(_M_fnumget))
355		_M_fnumget->get(*this, 0, *this, __err, __n);
356	      this->setstate(__err);
357	    }
358	  catch(...)
359	    {
360	      // 27.6.1.2.1 Common requirements.
361	      // Turn this on without causing an ios::failure to be thrown.
362	      this->_M_setstate(ios_base::badbit);
363	      if ((this->exceptions() & ios_base::badbit) != 0)
364		__throw_exception_again;
365	    }
366	}
367      return *this;
368    }
369#endif
370
371  template<typename _CharT, typename _Traits>
372    basic_istream<_CharT, _Traits>& 
373    basic_istream<_CharT, _Traits>::
374    operator>>(float& __n)
375    {
376      sentry __cerb(*this, false);
377      if (__cerb) 
378	{
379	  try 
380	    {
381	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
382	      if (_M_check_facet(_M_fnumget))
383		_M_fnumget->get(*this, 0, *this, __err, __n);
384	      this->setstate(__err);
385	    }
386	  catch(...)
387	    {
388	      // 27.6.1.2.1 Common requirements.
389	      // Turn this on without causing an ios::failure to be thrown.
390	      this->_M_setstate(ios_base::badbit);
391	      if ((this->exceptions() & ios_base::badbit) != 0)
392		__throw_exception_again;
393	    }
394	}
395      return *this;
396    }
397
398  template<typename _CharT, typename _Traits>
399    basic_istream<_CharT, _Traits>& 
400    basic_istream<_CharT, _Traits>::
401    operator>>(double& __n)
402    {
403      sentry __cerb(*this, false);
404      if (__cerb) 
405	{
406	  try 
407	    {
408	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
409	      if (_M_check_facet(_M_fnumget))
410		_M_fnumget->get(*this, 0, *this, __err, __n);
411	      this->setstate(__err);
412	    }
413	  catch(...)
414	    {
415	      // 27.6.1.2.1 Common requirements.
416	      // Turn this on without causing an ios::failure to be thrown.
417	      this->_M_setstate(ios_base::badbit);
418	      if ((this->exceptions() & ios_base::badbit) != 0)
419		__throw_exception_again;
420	    }
421	}
422      return *this;
423    }
424
425  template<typename _CharT, typename _Traits>
426    basic_istream<_CharT, _Traits>& 
427    basic_istream<_CharT, _Traits>::
428    operator>>(long double& __n)
429    {
430      sentry __cerb(*this, false);
431      if (__cerb) 
432	{
433	  try 
434	    {
435	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
436	      if (_M_check_facet(_M_fnumget))
437		_M_fnumget->get(*this, 0, *this, __err, __n);
438	      this->setstate(__err);
439	    }
440	  catch(...)
441	    {
442	      // 27.6.1.2.1 Common requirements.
443	      // Turn this on without causing an ios::failure to be thrown.
444	      this->_M_setstate(ios_base::badbit);
445	      if ((this->exceptions() & ios_base::badbit) != 0)
446		__throw_exception_again;
447	    }
448	}
449      return *this;
450    }
451
452  template<typename _CharT, typename _Traits>
453    basic_istream<_CharT, _Traits>& 
454    basic_istream<_CharT, _Traits>::
455    operator>>(void*& __n)
456    {
457      sentry __cerb(*this, false);
458      if (__cerb) 
459	{
460	  try 
461	    {
462	      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
463	      if (_M_check_facet(_M_fnumget))
464		_M_fnumget->get(*this, 0, *this, __err, __n);
465	      this->setstate(__err);
466	    }
467	  catch(...)
468	    {
469	      // 27.6.1.2.1 Common requirements.
470	      // Turn this on without causing an ios::failure to be thrown.
471	      this->_M_setstate(ios_base::badbit);
472	      if ((this->exceptions() & ios_base::badbit) != 0)
473		__throw_exception_again;
474	    }
475	}
476      return *this;
477    }
478
479  template<typename _CharT, typename _Traits>
480    basic_istream<_CharT, _Traits>& 
481    basic_istream<_CharT, _Traits>::
482    operator>>(__streambuf_type* __sbout)
483    {
484       sentry __cerb(*this, false);
485       if (__cerb)
486	 {
487	   try
488	     {
489	       streamsize __xtrct = 0;
490	       if (__sbout)
491		 {
492		   __streambuf_type* __sbin = this->rdbuf();
493		   __xtrct = __copy_streambufs(*this, __sbin, __sbout);
494		 }
495	       if (!__sbout || !__xtrct)
496		 this->setstate(ios_base::failbit);
497	     }
498	   catch(...)
499	     {
500	       // 27.6.2.5.1 Common requirements.
501	       // Turn this on without causing an ios::failure to be thrown.
502	       this->_M_setstate(ios_base::badbit);
503	       if ((this->exceptions() & ios_base::badbit) != 0)
504		 __throw_exception_again;
505	     }
506	 }
507       return *this;
508    }
509
510  template<typename _CharT, typename _Traits>
511    typename basic_istream<_CharT, _Traits>::int_type
512    basic_istream<_CharT, _Traits>::
513    get(void)
514    {
515      const int_type __eof = traits_type::eof();
516      int_type __c = __eof;
517      _M_gcount = 0;
518      sentry __cerb(*this, true);
519      if (__cerb) 
520	{
521	  try 
522	    {
523	      __c = this->rdbuf()->sbumpc();
524	      // 27.6.1.1 paragraph 3
525	      if (!traits_type::eq_int_type(__c, __eof))
526		_M_gcount = 1;
527	      else
528		this->setstate(ios_base::eofbit | ios_base::failbit);
529	    }
530	  catch(...)
531	    {
532	      // 27.6.1.3 paragraph 1
533	      // Turn this on without causing an ios::failure to be thrown.
534	      this->_M_setstate(ios_base::badbit);
535	      if ((this->exceptions() & ios_base::badbit) != 0)
536		__throw_exception_again;
537	    }
538	}
539      return __c;
540    }
541
542  template<typename _CharT, typename _Traits>
543    basic_istream<_CharT, _Traits>&
544    basic_istream<_CharT, _Traits>::
545    get(char_type& __c)
546    {
547      _M_gcount = 0;
548      sentry __cerb(*this, true);
549      if (__cerb) 
550	{
551 	  try 
552	    {
553	      const int_type __eof = traits_type::eof();
554	      int_type __bufval = this->rdbuf()->sbumpc();
555	      // 27.6.1.1 paragraph 3
556	      if (!traits_type::eq_int_type(__bufval, __eof))
557		{
558		  _M_gcount = 1;
559		  __c = traits_type::to_char_type(__bufval);
560		}
561	      else
562		this->setstate(ios_base::eofbit | ios_base::failbit);
563	    }
564	  catch(...)
565	    {
566	      // 27.6.1.3 paragraph 1
567	      // Turn this on without causing an ios::failure to be thrown.
568	      this->_M_setstate(ios_base::badbit);
569	      if ((this->exceptions() & ios_base::badbit) != 0)
570		__throw_exception_again;
571	    }
572	}
573      return *this;
574    }
575
576  template<typename _CharT, typename _Traits>
577    basic_istream<_CharT, _Traits>&
578    basic_istream<_CharT, _Traits>::
579    get(char_type* __s, streamsize __n, char_type __delim)
580    {
581      _M_gcount = 0;
582      sentry __cerb(*this, true);
583      if (__cerb) 
584	{
585	  try 
586	    {
587	      const int_type __idelim = traits_type::to_int_type(__delim);
588	      const int_type __eof = traits_type::eof();
589	      __streambuf_type* __sb = this->rdbuf();
590	      int_type __c = __sb->sgetc();	
591	      
592	      while (_M_gcount + 1 < __n 
593		     && !traits_type::eq_int_type(__c, __eof)
594		     && !traits_type::eq_int_type(__c, __idelim))
595		{
596		  *__s++ = traits_type::to_char_type(__c);
597		  __c = __sb->snextc();
598		  ++_M_gcount;
599		}
600	      if (traits_type::eq_int_type(__c, __eof))
601		this->setstate(ios_base::eofbit);
602	    }
603	  catch(...)
604	    {
605	      // 27.6.1.3 paragraph 1
606	      // Turn this on without causing an ios::failure to be thrown.
607	      this->_M_setstate(ios_base::badbit);
608	      if ((this->exceptions() & ios_base::badbit) != 0)
609		__throw_exception_again;
610	    }
611	}
612      *__s = char_type();
613      if (!_M_gcount)
614	this->setstate(ios_base::failbit);
615      return *this;
616    }
617
618  template<typename _CharT, typename _Traits>
619    basic_istream<_CharT, _Traits>&
620    basic_istream<_CharT, _Traits>::
621    get(__streambuf_type& __sb, char_type __delim)
622    {
623      _M_gcount = 0;
624      sentry __cerb(*this, true);
625      if (__cerb) 
626	{
627	  try 
628	    {
629	      const int_type __idelim = traits_type::to_int_type(__delim);
630	      const int_type __eof = traits_type::eof();	      
631	      __streambuf_type* __this_sb = this->rdbuf();
632	      int_type __c = __this_sb->sgetc();
633	      char_type __c2 = traits_type::to_char_type(__c);
634	      
635	      while (!traits_type::eq_int_type(__c, __eof) 
636		     && !traits_type::eq_int_type(__c, __idelim) 
637		     && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
638		{
639		  ++_M_gcount;
640		  __c = __this_sb->snextc();
641		  __c2 = traits_type::to_char_type(__c);
642		}
643	      if (traits_type::eq_int_type(__c, __eof))
644		this->setstate(ios_base::eofbit);
645	    }
646	  catch(...)
647	    {
648	      // 27.6.1.3 paragraph 1
649	      // Turn this on without causing an ios::failure to be thrown.
650	      this->_M_setstate(ios_base::badbit);
651	      if ((this->exceptions() & ios_base::badbit) != 0)
652		__throw_exception_again;
653	    }
654	}
655      if (!_M_gcount)
656	this->setstate(ios_base::failbit);
657      return *this;
658    }
659
660  template<typename _CharT, typename _Traits>
661    basic_istream<_CharT, _Traits>&
662    basic_istream<_CharT, _Traits>::
663    getline(char_type* __s, streamsize __n, char_type __delim)
664    {
665      _M_gcount = 0;
666      sentry __cerb(*this, true);
667      if (__cerb) 
668	{
669          try 
670	    {
671	      const int_type __idelim = traits_type::to_int_type(__delim);
672	      const int_type __eof = traits_type::eof();
673	      __streambuf_type* __sb = this->rdbuf();
674	      int_type __c = __sb->sgetc();
675	    
676	      while (_M_gcount + 1 < __n 
677		     && !traits_type::eq_int_type(__c, __eof)
678		     && !traits_type::eq_int_type(__c, __idelim))
679		{
680		  *__s++ = traits_type::to_char_type(__c);
681		  __c = __sb->snextc();
682		  ++_M_gcount;
683		}
684	      if (traits_type::eq_int_type(__c, __eof))
685		this->setstate(ios_base::eofbit);
686	      else
687		{
688		  if (traits_type::eq_int_type(__c, __idelim))
689		    {
690		      __sb->sbumpc();
691		      ++_M_gcount;
692		    }
693		  else
694		    this->setstate(ios_base::failbit);
695		}
696	    }
697	  catch(...)
698	    {
699	      // 27.6.1.3 paragraph 1
700	      // Turn this on without causing an ios::failure to be thrown.
701	      this->_M_setstate(ios_base::badbit);
702	      if ((this->exceptions() & ios_base::badbit) != 0)
703		__throw_exception_again;
704	    }
705	}
706      *__s = char_type();
707      if (!_M_gcount)
708	this->setstate(ios_base::failbit);
709      return *this;
710    }
711  
712  template<typename _CharT, typename _Traits>
713    basic_istream<_CharT, _Traits>&
714    basic_istream<_CharT, _Traits>::
715    ignore(streamsize __n, int_type __delim)
716    {
717      _M_gcount = 0;
718      sentry __cerb(*this, true);
719      if (__cerb && __n > 0) 
720	{
721	  try 
722	    {
723	      const int_type __eof = traits_type::eof();
724	      __streambuf_type* __sb = this->rdbuf();
725	      int_type __c;
726	      
727	      __n = min(__n, numeric_limits<streamsize>::max());
728	      while (_M_gcount < __n  
729		     && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
730		{
731		  ++_M_gcount;
732		  if (traits_type::eq_int_type(__c, __delim))
733		    break;
734		}
735	      if (traits_type::eq_int_type(__c, __eof))
736		this->setstate(ios_base::eofbit);
737	    }
738	  catch(...)
739	    {
740	      // 27.6.1.3 paragraph 1
741	      // Turn this on without causing an ios::failure to be thrown.
742	      this->_M_setstate(ios_base::badbit);
743	      if ((this->exceptions() & ios_base::badbit) != 0)
744		__throw_exception_again;
745	    }
746	}
747      return *this;
748    }
749  
750  template<typename _CharT, typename _Traits>
751    typename basic_istream<_CharT, _Traits>::int_type
752    basic_istream<_CharT, _Traits>::
753    peek(void)
754    {
755      int_type __c = traits_type::eof();
756      _M_gcount = 0;
757      sentry __cerb(*this, true);
758      if (__cerb)
759	{
760	  try 
761	    { __c = this->rdbuf()->sgetc(); }
762	  catch(...)
763	    {
764	      // 27.6.1.3 paragraph 1
765	      // Turn this on without causing an ios::failure to be thrown.
766	      this->_M_setstate(ios_base::badbit);
767	      if ((this->exceptions() & ios_base::badbit) != 0)
768		__throw_exception_again;
769	    }
770	} 
771      return __c;
772    }
773
774  template<typename _CharT, typename _Traits>
775    basic_istream<_CharT, _Traits>&
776    basic_istream<_CharT, _Traits>::
777    read(char_type* __s, streamsize __n)
778    {
779      _M_gcount = 0;
780      sentry __cerb(*this, true);
781      if (__cerb) 
782	{
783	  try 
784	    {
785	      _M_gcount = this->rdbuf()->sgetn(__s, __n);
786	      if (_M_gcount != __n)
787		this->setstate(ios_base::eofbit | ios_base::failbit);
788	    }	    
789	  catch(...)
790	    {
791	      // 27.6.1.3 paragraph 1
792	      // Turn this on without causing an ios::failure to be thrown.
793	      this->_M_setstate(ios_base::badbit);
794	      if ((this->exceptions() & ios_base::badbit) != 0)
795		__throw_exception_again;
796	    }
797	}
798      else
799	this->setstate(ios_base::failbit);
800      return *this;
801    }
802  
803  template<typename _CharT, typename _Traits>
804    streamsize 
805    basic_istream<_CharT, _Traits>::
806    readsome(char_type* __s, streamsize __n)
807    {
808      _M_gcount = 0;
809      sentry __cerb(*this, true);
810      if (__cerb) 
811	{
812	  try 
813	    {
814	      // Cannot compare int_type with streamsize generically.
815	      streamsize __num = this->rdbuf()->in_avail();
816	      if (__num >= 0)
817		{
818		  __num = min(__num, __n);
819		  if (__num)
820		    _M_gcount = this->rdbuf()->sgetn(__s, __num);
821		}
822	      else
823		this->setstate(ios_base::eofbit);		    
824	    }
825	  catch(...)
826	    {
827	      // 27.6.1.3 paragraph 1
828	      // Turn this on without causing an ios::failure to be thrown.
829	      this->_M_setstate(ios_base::badbit);
830	      if ((this->exceptions() & ios_base::badbit) != 0)
831		__throw_exception_again;
832	    }
833	}
834      else
835	this->setstate(ios_base::failbit);
836      return _M_gcount;
837    }
838      
839  template<typename _CharT, typename _Traits>
840    basic_istream<_CharT, _Traits>&
841    basic_istream<_CharT, _Traits>::
842    putback(char_type __c)
843    {
844#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
845// 60. What is a formatted input function?
846      _M_gcount = 0;
847#endif
848      sentry __cerb(*this, true);
849      if (__cerb) 
850	{
851	  try 
852	    {
853	      const int_type __eof = traits_type::eof();
854	      __streambuf_type* __sb = this->rdbuf();
855	      if (!__sb 
856		  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
857		this->setstate(ios_base::badbit);		    
858	    }
859	  catch(...)
860	    {
861	      // 27.6.1.3 paragraph 1
862	      // Turn this on without causing an ios::failure to be thrown.
863	      this->_M_setstate(ios_base::badbit);
864	      if ((this->exceptions() & ios_base::badbit) != 0)
865		__throw_exception_again;
866	    }
867	}
868      else
869	this->setstate(ios_base::failbit);
870      return *this;
871    }
872  
873  template<typename _CharT, typename _Traits>
874    basic_istream<_CharT, _Traits>&
875    basic_istream<_CharT, _Traits>::
876    unget(void)
877    {
878#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
879// 60. What is a formatted input function?
880      _M_gcount = 0;
881#endif
882      sentry __cerb(*this, true);
883      if (__cerb) 
884	{
885	  try 
886	    {
887	      const int_type __eof = traits_type::eof();
888	      __streambuf_type* __sb = this->rdbuf();
889	      if (!__sb 
890		  || traits_type::eq_int_type(__sb->sungetc(), __eof))
891		this->setstate(ios_base::badbit);		    
892	    }
893	  catch(...)
894	    {
895	      // 27.6.1.3 paragraph 1
896	      // Turn this on without causing an ios::failure to be thrown.
897	      this->_M_setstate(ios_base::badbit);
898	      if ((this->exceptions() & ios_base::badbit) != 0)
899		__throw_exception_again;
900	    }
901	}
902      else
903	this->setstate(ios_base::failbit);
904      return *this;
905    }
906  
907  template<typename _CharT, typename _Traits>
908    int
909    basic_istream<_CharT, _Traits>::
910    sync(void)
911    {
912      // DR60.  Do not change _M_gcount.
913      int __ret = -1;
914      sentry __cerb(*this, true);
915      if (__cerb) 
916	{
917	  try 
918	    {
919	      __streambuf_type* __sb = this->rdbuf();
920	      if (__sb)
921		{
922		  if (__sb->pubsync() == -1)
923		    this->setstate(ios_base::badbit);		    
924		  else 
925		    __ret = 0;
926		}
927	    }
928	  catch(...)
929	    {
930	      // 27.6.1.3 paragraph 1
931	      // Turn this on without causing an ios::failure to be thrown.
932	      this->_M_setstate(ios_base::badbit);
933	      if ((this->exceptions() & ios_base::badbit) != 0)
934		__throw_exception_again;
935	    }
936	}
937      return __ret;
938    }
939  
940  template<typename _CharT, typename _Traits>
941    typename basic_istream<_CharT, _Traits>::pos_type
942    basic_istream<_CharT, _Traits>::
943    tellg(void)
944    {
945      // DR60.  Do not change _M_gcount.
946      pos_type __ret = pos_type(-1);
947      if (!this->fail())
948	__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
949      return __ret;
950    }
951
952
953  template<typename _CharT, typename _Traits>
954    basic_istream<_CharT, _Traits>&
955    basic_istream<_CharT, _Traits>::
956    seekg(pos_type __pos)
957    {
958      // DR60.  Do not change _M_gcount.
959      if (!this->fail())
960	{
961#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
962// 136.  seekp, seekg setting wrong streams?
963	  pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);
964
965// 129. Need error indication from seekp() and seekg()
966	  if (__err == pos_type(off_type(-1)))
967	    this->setstate(ios_base::failbit);
968#endif
969	}
970      return *this;
971    }
972
973  template<typename _CharT, typename _Traits>
974    basic_istream<_CharT, _Traits>&
975    basic_istream<_CharT, _Traits>::
976    seekg(off_type __off, ios_base::seekdir __dir)
977    {
978      // DR60.  Do not change _M_gcount.
979      if (!this->fail())
980	{
981#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
982// 136.  seekp, seekg setting wrong streams?
983	  pos_type __err = this->rdbuf()->pubseekoff(__off, __dir, 
984						     ios_base::in);
985
986// 129. Need error indication from seekp() and seekg()
987	  if (__err == pos_type(off_type(-1)))
988	    this->setstate(ios_base::failbit);
989#endif
990	}
991      return *this;
992    }
993
994  // 27.6.1.2.3 Character extraction templates
995  template<typename _CharT, typename _Traits>
996    basic_istream<_CharT, _Traits>&
997    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
998    {
999      typedef basic_istream<_CharT, _Traits> 		__istream_type;
1000      typename __istream_type::sentry __cerb(__in, false);
1001      if (__cerb)
1002	{
1003	  try 
1004	    { __in.get(__c); }
1005	  catch(...)
1006	    {
1007	      // 27.6.1.2.1 Common requirements.
1008	      // Turn this on without causing an ios::failure to be thrown.
1009	      __in._M_setstate(ios_base::badbit);
1010	      if ((__in.exceptions() & ios_base::badbit) != 0)
1011		__throw_exception_again;
1012	    }
1013	}
1014      else
1015	__in.setstate(ios_base::failbit);
1016      return __in;
1017    }
1018
1019  template<typename _CharT, typename _Traits>
1020    basic_istream<_CharT, _Traits>&
1021    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
1022    {
1023      typedef basic_istream<_CharT, _Traits> 		__istream_type;
1024      typedef typename __istream_type::__streambuf_type __streambuf_type;
1025      typedef typename _Traits::int_type 		int_type;
1026      typedef _CharT                     		char_type;
1027      typedef ctype<_CharT>     			__ctype_type;
1028      streamsize __extracted = 0;
1029
1030      typename __istream_type::sentry __cerb(__in, false);
1031      if (__cerb)
1032	{
1033	  try 
1034	    {
1035	      // Figure out how many characters to extract.
1036	      streamsize __num = __in.width();
1037	      if (__num <= 0)
1038		__num = numeric_limits<streamsize>::max();
1039	      
1040	      const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1041	      const int_type __eof = _Traits::eof();
1042	      __streambuf_type* __sb = __in.rdbuf();
1043	      int_type __c = __sb->sgetc();
1044	      
1045	      while (__extracted < __num - 1 
1046		     && !_Traits::eq_int_type(__c, __eof)
1047		     && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
1048		{
1049		  *__s++ = _Traits::to_char_type(__c);
1050		  ++__extracted;
1051		  __c = __sb->snextc();
1052		}
1053	      if (_Traits::eq_int_type(__c, __eof))
1054		__in.setstate(ios_base::eofbit);
1055
1056#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1057//68.  Extractors for char* should store null at end
1058	      *__s = char_type();
1059#endif
1060	      __in.width(0);
1061	    }
1062	  catch(...)
1063	    {
1064	      // 27.6.1.2.1 Common requirements.
1065	      // Turn this on without causing an ios::failure to be thrown.
1066	      __in._M_setstate(ios_base::badbit);
1067	      if ((__in.exceptions() & ios_base::badbit) != 0)
1068		__throw_exception_again;
1069	    }
1070	}
1071      if (!__extracted)
1072	__in.setstate(ios_base::failbit);
1073      return __in;
1074    }
1075
1076  // 27.6.1.4 Standard basic_istream manipulators
1077  template<typename _CharT, typename _Traits>
1078    basic_istream<_CharT,_Traits>& 
1079    ws(basic_istream<_CharT,_Traits>& __in)
1080    {
1081      typedef basic_istream<_CharT, _Traits> 		__istream_type;
1082      typedef typename __istream_type::__streambuf_type __streambuf_type;
1083      typedef typename __istream_type::__ctype_type 	__ctype_type;
1084      typedef typename __istream_type::int_type 	__int_type;
1085
1086      const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1087      const __int_type __eof = _Traits::eof();	      
1088      __streambuf_type* __sb = __in.rdbuf();
1089      __int_type __c = __sb->sgetc();
1090
1091      while (!_Traits::eq_int_type(__c, __eof) 
1092	     && __ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
1093	__c = __sb->snextc();
1094
1095       if (_Traits::eq_int_type(__c, __eof))
1096	__in.setstate(ios_base::eofbit);
1097
1098      return __in;
1099    }
1100
1101  // 21.3.7.9 basic_string::getline and operators
1102  template<typename _CharT, typename _Traits, typename _Alloc>
1103    basic_istream<_CharT, _Traits>&
1104    operator>>(basic_istream<_CharT, _Traits>& __in,
1105	       basic_string<_CharT, _Traits, _Alloc>& __str)
1106    {
1107      typedef basic_istream<_CharT, _Traits> 		__istream_type;
1108      typedef typename __istream_type::int_type 	__int_type;
1109      typedef typename __istream_type::__streambuf_type __streambuf_type;
1110      typedef typename __istream_type::__ctype_type 	__ctype_type;
1111      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
1112      typedef typename __string_type::size_type		__size_type;
1113      __size_type __extracted = 0;
1114
1115      typename __istream_type::sentry __cerb(__in, false);
1116      if (__cerb) 
1117	{
1118	  __str.erase();
1119	  streamsize __w = __in.width();
1120	  __size_type __n;
1121	  __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
1122
1123	  const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1124	  const __int_type __eof = _Traits::eof();
1125	  __streambuf_type* __sb = __in.rdbuf();
1126	  __int_type __c = __sb->sgetc();
1127	  
1128	  while (__extracted < __n 
1129		 && !_Traits::eq_int_type(__c, __eof)
1130		 && !__ctype.is(ctype_base::space, _Traits::to_char_type(__c)))
1131	    {
1132	      __str += _Traits::to_char_type(__c);
1133	      ++__extracted;
1134	      __c = __sb->snextc();
1135	    }
1136	  if (_Traits::eq_int_type(__c, __eof))
1137	    __in.setstate(ios_base::eofbit);
1138	  __in.width(0);
1139	}
1140#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1141//211.  operator>>(istream&, string&) doesn't set failbit
1142      if (!__extracted)
1143	__in.setstate (ios_base::failbit);
1144#endif
1145      return __in;
1146    }
1147
1148  template<typename _CharT, typename _Traits, typename _Alloc>
1149    basic_istream<_CharT, _Traits>&
1150    getline(basic_istream<_CharT, _Traits>& __in,
1151	    basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
1152    {
1153      typedef basic_istream<_CharT, _Traits> 		__istream_type;
1154      typedef typename __istream_type::int_type 	__int_type;
1155      typedef typename __istream_type::__streambuf_type __streambuf_type;
1156      typedef typename __istream_type::__ctype_type 	__ctype_type;
1157      typedef basic_string<_CharT, _Traits, _Alloc> 	__string_type;
1158      typedef typename __string_type::size_type		__size_type;
1159
1160      __size_type __extracted = 0;
1161      bool __testdelim = false;
1162      typename __istream_type::sentry __cerb(__in, true);
1163      if (__cerb) 
1164	{
1165	  __str.erase();
1166	  __size_type __n = __str.max_size();
1167
1168	  __int_type __idelim = _Traits::to_int_type(__delim);
1169	  __streambuf_type* __sb = __in.rdbuf();
1170	  __int_type __c = __sb->sbumpc();
1171	  const __int_type __eof = _Traits::eof();
1172	  __testdelim = _Traits::eq_int_type(__c, __idelim);
1173
1174	  while (__extracted <= __n 
1175		 && !_Traits::eq_int_type(__c, __eof)
1176		 && !__testdelim)
1177	    {
1178	      __str += _Traits::to_char_type(__c);
1179	      ++__extracted;
1180	      __c = __sb->sbumpc();
1181	      __testdelim = _Traits::eq_int_type(__c, __idelim);
1182	    }
1183	  if (_Traits::eq_int_type(__c, __eof))
1184	    __in.setstate(ios_base::eofbit);
1185	}
1186      if (!__extracted && !__testdelim)
1187	__in.setstate(ios_base::failbit);
1188      return __in;
1189    }
1190
1191  template<class _CharT, class _Traits, class _Alloc>
1192    inline basic_istream<_CharT,_Traits>&
1193    getline(basic_istream<_CharT, _Traits>& __in, 
1194	    basic_string<_CharT,_Traits,_Alloc>& __str)
1195    { return getline(__in, __str, __in.widen('\n')); }
1196
1197  // Inhibit implicit instantiations for required instantiations,
1198  // which are defined via explicit instantiations elsewhere.  
1199  // NB:  This syntax is a GNU extension.
1200#if _GLIBCPP_EXTERN_TEMPLATE
1201  extern template class basic_istream<char>;
1202  extern template istream& ws(istream&);
1203  extern template istream& operator>>(istream&, char&);
1204  extern template istream& operator>>(istream&, char*);
1205  extern template istream& operator>>(istream&, unsigned char&);
1206  extern template istream& operator>>(istream&, signed char&);
1207  extern template istream& operator>>(istream&, unsigned char*);
1208  extern template istream& operator>>(istream&, signed char*);
1209
1210#ifdef _GLIBCPP_USE_WCHAR_T
1211  extern template class basic_istream<wchar_t>;
1212  extern template wistream& ws(wistream&);
1213  extern template wistream& operator>>(wistream&, wchar_t&);
1214  extern template wistream& operator>>(wistream&, wchar_t*);
1215#endif
1216#endif
1217} // namespace std
1218