libstdc++
istream.tcc
Go to the documentation of this file.
1 // istream classes -*- C++ -*-
2 
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 // 2006, 2007, 2008, 2009
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 istream.tcc
28  * This is an internal header file, included by other library headers.
29  * You should not attempt to use it directly.
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 <cxxabi-forced.h>
42 
43 _GLIBCXX_BEGIN_NAMESPACE(std)
44 
45  template<typename _CharT, typename _Traits>
46  basic_istream<_CharT, _Traits>::sentry::
47  sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
48  {
49  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
50  if (__in.good())
51  {
52  if (__in.tie())
53  __in.tie()->flush();
54  if (!__noskip && bool(__in.flags() & ios_base::skipws))
55  {
56  const __int_type __eof = traits_type::eof();
57  __streambuf_type* __sb = __in.rdbuf();
58  __int_type __c = __sb->sgetc();
59 
60  const __ctype_type& __ct = __check_facet(__in._M_ctype);
61  while (!traits_type::eq_int_type(__c, __eof)
62  && __ct.is(ctype_base::space,
63  traits_type::to_char_type(__c)))
64  __c = __sb->snextc();
65 
66  // _GLIBCXX_RESOLVE_LIB_DEFECTS
67  // 195. Should basic_istream::sentry's constructor ever
68  // set eofbit?
69  if (traits_type::eq_int_type(__c, __eof))
70  __err |= ios_base::eofbit;
71  }
72  }
73 
74  if (__in.good() && __err == ios_base::goodbit)
75  _M_ok = true;
76  else
77  {
78  __err |= ios_base::failbit;
79  __in.setstate(__err);
80  }
81  }
82 
83  template<typename _CharT, typename _Traits>
84  template<typename _ValueT>
87  _M_extract(_ValueT& __v)
88  {
89  sentry __cerb(*this, false);
90  if (__cerb)
91  {
92  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
93  __try
94  {
95  const __num_get_type& __ng = __check_facet(this->_M_num_get);
96  __ng.get(*this, 0, *this, __err, __v);
97  }
99  {
100  this->_M_setstate(ios_base::badbit);
101  __throw_exception_again;
102  }
103  __catch(...)
104  { this->_M_setstate(ios_base::badbit); }
105  if (__err)
106  this->setstate(__err);
107  }
108  return *this;
109  }
110 
111  template<typename _CharT, typename _Traits>
112  basic_istream<_CharT, _Traits>&
114  operator>>(short& __n)
115  {
116  // _GLIBCXX_RESOLVE_LIB_DEFECTS
117  // 118. basic_istream uses nonexistent num_get member functions.
118  long __l;
119  _M_extract(__l);
120  if (!this->fail())
121  {
122  if (__gnu_cxx::__numeric_traits<short>::__min <= __l
123  && __l <= __gnu_cxx::__numeric_traits<short>::__max)
124  __n = short(__l);
125  else
126  this->setstate(ios_base::failbit);
127  }
128  return *this;
129  }
130 
131  template<typename _CharT, typename _Traits>
134  operator>>(int& __n)
135  {
136  // _GLIBCXX_RESOLVE_LIB_DEFECTS
137  // 118. basic_istream uses nonexistent num_get member functions.
138  long __l;
139  _M_extract(__l);
140  if (!this->fail())
141  {
142  if (__gnu_cxx::__numeric_traits<int>::__min <= __l
143  && __l <= __gnu_cxx::__numeric_traits<int>::__max)
144  __n = int(__l);
145  else
146  this->setstate(ios_base::failbit);
147  }
148  return *this;
149  }
150 
151  template<typename _CharT, typename _Traits>
155  {
156  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
157  sentry __cerb(*this, false);
158  if (__cerb && __sbout)
159  {
160  __try
161  {
162  bool __ineof;
163  if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
164  __err |= ios_base::failbit;
165  if (__ineof)
166  __err |= ios_base::eofbit;
167  }
169  {
170  this->_M_setstate(ios_base::failbit);
171  __throw_exception_again;
172  }
173  __catch(...)
174  { this->_M_setstate(ios_base::failbit); }
175  }
176  else if (!__sbout)
177  __err |= ios_base::failbit;
178  if (__err)
179  this->setstate(__err);
180  return *this;
181  }
182 
183  template<typename _CharT, typename _Traits>
184  typename basic_istream<_CharT, _Traits>::int_type
186  get(void)
187  {
188  const int_type __eof = traits_type::eof();
189  int_type __c = __eof;
190  _M_gcount = 0;
191  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
192  sentry __cerb(*this, true);
193  if (__cerb)
194  {
195  __try
196  {
197  __c = this->rdbuf()->sbumpc();
198  // 27.6.1.1 paragraph 3
199  if (!traits_type::eq_int_type(__c, __eof))
200  _M_gcount = 1;
201  else
202  __err |= ios_base::eofbit;
203  }
205  {
206  this->_M_setstate(ios_base::badbit);
207  __throw_exception_again;
208  }
209  __catch(...)
210  { this->_M_setstate(ios_base::badbit); }
211  }
212  if (!_M_gcount)
213  __err |= ios_base::failbit;
214  if (__err)
215  this->setstate(__err);
216  return __c;
217  }
218 
219  template<typename _CharT, typename _Traits>
222  get(char_type& __c)
223  {
224  _M_gcount = 0;
225  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
226  sentry __cerb(*this, true);
227  if (__cerb)
228  {
229  __try
230  {
231  const int_type __cb = this->rdbuf()->sbumpc();
232  // 27.6.1.1 paragraph 3
233  if (!traits_type::eq_int_type(__cb, traits_type::eof()))
234  {
235  _M_gcount = 1;
236  __c = traits_type::to_char_type(__cb);
237  }
238  else
239  __err |= ios_base::eofbit;
240  }
242  {
243  this->_M_setstate(ios_base::badbit);
244  __throw_exception_again;
245  }
246  __catch(...)
247  { this->_M_setstate(ios_base::badbit); }
248  }
249  if (!_M_gcount)
250  __err |= ios_base::failbit;
251  if (__err)
252  this->setstate(__err);
253  return *this;
254  }
255 
256  template<typename _CharT, typename _Traits>
259  get(char_type* __s, streamsize __n, char_type __delim)
260  {
261  _M_gcount = 0;
262  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
263  sentry __cerb(*this, true);
264  if (__cerb)
265  {
266  __try
267  {
268  const int_type __idelim = traits_type::to_int_type(__delim);
269  const int_type __eof = traits_type::eof();
270  __streambuf_type* __sb = this->rdbuf();
271  int_type __c = __sb->sgetc();
272 
273  while (_M_gcount + 1 < __n
274  && !traits_type::eq_int_type(__c, __eof)
275  && !traits_type::eq_int_type(__c, __idelim))
276  {
277  *__s++ = traits_type::to_char_type(__c);
278  ++_M_gcount;
279  __c = __sb->snextc();
280  }
281  if (traits_type::eq_int_type(__c, __eof))
282  __err |= ios_base::eofbit;
283  }
285  {
286  this->_M_setstate(ios_base::badbit);
287  __throw_exception_again;
288  }
289  __catch(...)
290  { this->_M_setstate(ios_base::badbit); }
291  }
292  // _GLIBCXX_RESOLVE_LIB_DEFECTS
293  // 243. get and getline when sentry reports failure.
294  if (__n > 0)
295  *__s = char_type();
296  if (!_M_gcount)
297  __err |= ios_base::failbit;
298  if (__err)
299  this->setstate(__err);
300  return *this;
301  }
302 
303  template<typename _CharT, typename _Traits>
306  get(__streambuf_type& __sb, char_type __delim)
307  {
308  _M_gcount = 0;
309  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
310  sentry __cerb(*this, true);
311  if (__cerb)
312  {
313  __try
314  {
315  const int_type __idelim = traits_type::to_int_type(__delim);
316  const int_type __eof = traits_type::eof();
317  __streambuf_type* __this_sb = this->rdbuf();
318  int_type __c = __this_sb->sgetc();
319  char_type __c2 = traits_type::to_char_type(__c);
320 
321  while (!traits_type::eq_int_type(__c, __eof)
322  && !traits_type::eq_int_type(__c, __idelim)
323  && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
324  {
325  ++_M_gcount;
326  __c = __this_sb->snextc();
327  __c2 = traits_type::to_char_type(__c);
328  }
329  if (traits_type::eq_int_type(__c, __eof))
330  __err |= ios_base::eofbit;
331  }
333  {
334  this->_M_setstate(ios_base::badbit);
335  __throw_exception_again;
336  }
337  __catch(...)
338  { this->_M_setstate(ios_base::badbit); }
339  }
340  if (!_M_gcount)
341  __err |= ios_base::failbit;
342  if (__err)
343  this->setstate(__err);
344  return *this;
345  }
346 
347  template<typename _CharT, typename _Traits>
350  getline(char_type* __s, streamsize __n, char_type __delim)
351  {
352  _M_gcount = 0;
353  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
354  sentry __cerb(*this, true);
355  if (__cerb)
356  {
357  __try
358  {
359  const int_type __idelim = traits_type::to_int_type(__delim);
360  const int_type __eof = traits_type::eof();
361  __streambuf_type* __sb = this->rdbuf();
362  int_type __c = __sb->sgetc();
363 
364  while (_M_gcount + 1 < __n
365  && !traits_type::eq_int_type(__c, __eof)
366  && !traits_type::eq_int_type(__c, __idelim))
367  {
368  *__s++ = traits_type::to_char_type(__c);
369  __c = __sb->snextc();
370  ++_M_gcount;
371  }
372  if (traits_type::eq_int_type(__c, __eof))
373  __err |= ios_base::eofbit;
374  else
375  {
376  if (traits_type::eq_int_type(__c, __idelim))
377  {
378  __sb->sbumpc();
379  ++_M_gcount;
380  }
381  else
382  __err |= ios_base::failbit;
383  }
384  }
386  {
387  this->_M_setstate(ios_base::badbit);
388  __throw_exception_again;
389  }
390  __catch(...)
391  { this->_M_setstate(ios_base::badbit); }
392  }
393  // _GLIBCXX_RESOLVE_LIB_DEFECTS
394  // 243. get and getline when sentry reports failure.
395  if (__n > 0)
396  *__s = char_type();
397  if (!_M_gcount)
398  __err |= ios_base::failbit;
399  if (__err)
400  this->setstate(__err);
401  return *this;
402  }
403 
404  // We provide three overloads, since the first two are much simpler
405  // than the general case. Also, the latter two can thus adopt the
406  // same "batchy" strategy used by getline above.
407  template<typename _CharT, typename _Traits>
410  ignore(void)
411  {
412  _M_gcount = 0;
413  sentry __cerb(*this, true);
414  if (__cerb)
415  {
416  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
417  __try
418  {
419  const int_type __eof = traits_type::eof();
420  __streambuf_type* __sb = this->rdbuf();
421 
422  if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
423  __err |= ios_base::eofbit;
424  else
425  _M_gcount = 1;
426  }
428  {
429  this->_M_setstate(ios_base::badbit);
430  __throw_exception_again;
431  }
432  __catch(...)
433  { this->_M_setstate(ios_base::badbit); }
434  if (__err)
435  this->setstate(__err);
436  }
437  return *this;
438  }
439 
440  template<typename _CharT, typename _Traits>
444  {
445  _M_gcount = 0;
446  sentry __cerb(*this, true);
447  if (__cerb && __n > 0)
448  {
449  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
450  __try
451  {
452  const int_type __eof = traits_type::eof();
453  __streambuf_type* __sb = this->rdbuf();
454  int_type __c = __sb->sgetc();
455 
456  // N.B. On LFS-enabled platforms streamsize is still 32 bits
457  // wide: if we want to implement the standard mandated behavior
458  // for n == max() (see 27.6.1.3/24) we are at risk of signed
459  // integer overflow: thus these contortions. Also note that,
460  // by definition, when more than 2G chars are actually ignored,
461  // _M_gcount (the return value of gcount, that is) cannot be
462  // really correct, being unavoidably too small.
463  bool __large_ignore = false;
464  while (true)
465  {
466  while (_M_gcount < __n
467  && !traits_type::eq_int_type(__c, __eof))
468  {
469  ++_M_gcount;
470  __c = __sb->snextc();
471  }
472  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
473  && !traits_type::eq_int_type(__c, __eof))
474  {
475  _M_gcount =
476  __gnu_cxx::__numeric_traits<streamsize>::__min;
477  __large_ignore = true;
478  }
479  else
480  break;
481  }
482 
483  if (__large_ignore)
484  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
485 
486  if (traits_type::eq_int_type(__c, __eof))
487  __err |= ios_base::eofbit;
488  }
490  {
491  this->_M_setstate(ios_base::badbit);
492  __throw_exception_again;
493  }
494  __catch(...)
495  { this->_M_setstate(ios_base::badbit); }
496  if (__err)
497  this->setstate(__err);
498  }
499  return *this;
500  }
501 
502  template<typename _CharT, typename _Traits>
505  ignore(streamsize __n, int_type __delim)
506  {
507  _M_gcount = 0;
508  sentry __cerb(*this, true);
509  if (__cerb && __n > 0)
510  {
511  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
512  __try
513  {
514  const int_type __eof = traits_type::eof();
515  __streambuf_type* __sb = this->rdbuf();
516  int_type __c = __sb->sgetc();
517 
518  // See comment above.
519  bool __large_ignore = false;
520  while (true)
521  {
522  while (_M_gcount < __n
523  && !traits_type::eq_int_type(__c, __eof)
524  && !traits_type::eq_int_type(__c, __delim))
525  {
526  ++_M_gcount;
527  __c = __sb->snextc();
528  }
529  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
530  && !traits_type::eq_int_type(__c, __eof)
531  && !traits_type::eq_int_type(__c, __delim))
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  else if (traits_type::eq_int_type(__c, __delim))
547  {
548  if (_M_gcount
549  < __gnu_cxx::__numeric_traits<streamsize>::__max)
550  ++_M_gcount;
551  __sb->sbumpc();
552  }
553  }
555  {
556  this->_M_setstate(ios_base::badbit);
557  __throw_exception_again;
558  }
559  __catch(...)
560  { this->_M_setstate(ios_base::badbit); }
561  if (__err)
562  this->setstate(__err);
563  }
564  return *this;
565  }
566 
567  template<typename _CharT, typename _Traits>
568  typename basic_istream<_CharT, _Traits>::int_type
570  peek(void)
571  {
572  int_type __c = traits_type::eof();
573  _M_gcount = 0;
574  sentry __cerb(*this, true);
575  if (__cerb)
576  {
577  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
578  __try
579  {
580  __c = this->rdbuf()->sgetc();
581  if (traits_type::eq_int_type(__c, traits_type::eof()))
582  __err |= ios_base::eofbit;
583  }
585  {
586  this->_M_setstate(ios_base::badbit);
587  __throw_exception_again;
588  }
589  __catch(...)
590  { this->_M_setstate(ios_base::badbit); }
591  if (__err)
592  this->setstate(__err);
593  }
594  return __c;
595  }
596 
597  template<typename _CharT, typename _Traits>
600  read(char_type* __s, streamsize __n)
601  {
602  _M_gcount = 0;
603  sentry __cerb(*this, true);
604  if (__cerb)
605  {
606  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
607  __try
608  {
609  _M_gcount = this->rdbuf()->sgetn(__s, __n);
610  if (_M_gcount != __n)
611  __err |= (ios_base::eofbit | ios_base::failbit);
612  }
614  {
615  this->_M_setstate(ios_base::badbit);
616  __throw_exception_again;
617  }
618  __catch(...)
619  { this->_M_setstate(ios_base::badbit); }
620  if (__err)
621  this->setstate(__err);
622  }
623  return *this;
624  }
625 
626  template<typename _CharT, typename _Traits>
627  streamsize
629  readsome(char_type* __s, streamsize __n)
630  {
631  _M_gcount = 0;
632  sentry __cerb(*this, true);
633  if (__cerb)
634  {
635  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
636  __try
637  {
638  // Cannot compare int_type with streamsize generically.
639  const streamsize __num = this->rdbuf()->in_avail();
640  if (__num > 0)
641  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
642  else if (__num == -1)
643  __err |= ios_base::eofbit;
644  }
646  {
647  this->_M_setstate(ios_base::badbit);
648  __throw_exception_again;
649  }
650  __catch(...)
651  { this->_M_setstate(ios_base::badbit); }
652  if (__err)
653  this->setstate(__err);
654  }
655  return _M_gcount;
656  }
657 
658  template<typename _CharT, typename _Traits>
661  putback(char_type __c)
662  {
663  // _GLIBCXX_RESOLVE_LIB_DEFECTS
664  // 60. What is a formatted input function?
665  _M_gcount = 0;
666  sentry __cerb(*this, true);
667  if (__cerb)
668  {
669  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
670  __try
671  {
672  const int_type __eof = traits_type::eof();
673  __streambuf_type* __sb = this->rdbuf();
674  if (!__sb
675  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
676  __err |= ios_base::badbit;
677  }
679  {
680  this->_M_setstate(ios_base::badbit);
681  __throw_exception_again;
682  }
683  __catch(...)
684  { this->_M_setstate(ios_base::badbit); }
685  if (__err)
686  this->setstate(__err);
687  }
688  return *this;
689  }
690 
691  template<typename _CharT, typename _Traits>
694  unget(void)
695  {
696  // _GLIBCXX_RESOLVE_LIB_DEFECTS
697  // 60. What is a formatted input function?
698  _M_gcount = 0;
699  sentry __cerb(*this, true);
700  if (__cerb)
701  {
702  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
703  __try
704  {
705  const int_type __eof = traits_type::eof();
706  __streambuf_type* __sb = this->rdbuf();
707  if (!__sb
708  || traits_type::eq_int_type(__sb->sungetc(), __eof))
709  __err |= ios_base::badbit;
710  }
712  {
713  this->_M_setstate(ios_base::badbit);
714  __throw_exception_again;
715  }
716  __catch(...)
717  { this->_M_setstate(ios_base::badbit); }
718  if (__err)
719  this->setstate(__err);
720  }
721  return *this;
722  }
723 
724  template<typename _CharT, typename _Traits>
725  int
727  sync(void)
728  {
729  // _GLIBCXX_RESOLVE_LIB_DEFECTS
730  // DR60. Do not change _M_gcount.
731  int __ret = -1;
732  sentry __cerb(*this, true);
733  if (__cerb)
734  {
735  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
736  __try
737  {
738  __streambuf_type* __sb = this->rdbuf();
739  if (__sb)
740  {
741  if (__sb->pubsync() == -1)
742  __err |= ios_base::badbit;
743  else
744  __ret = 0;
745  }
746  }
748  {
749  this->_M_setstate(ios_base::badbit);
750  __throw_exception_again;
751  }
752  __catch(...)
753  { this->_M_setstate(ios_base::badbit); }
754  if (__err)
755  this->setstate(__err);
756  }
757  return __ret;
758  }
759 
760  template<typename _CharT, typename _Traits>
761  typename basic_istream<_CharT, _Traits>::pos_type
763  tellg(void)
764  {
765  // _GLIBCXX_RESOLVE_LIB_DEFECTS
766  // DR60. Do not change _M_gcount.
767  pos_type __ret = pos_type(-1);
768  __try
769  {
770  if (!this->fail())
771  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
772  ios_base::in);
773  }
775  {
776  this->_M_setstate(ios_base::badbit);
777  __throw_exception_again;
778  }
779  __catch(...)
780  { this->_M_setstate(ios_base::badbit); }
781  return __ret;
782  }
783 
784  template<typename _CharT, typename _Traits>
787  seekg(pos_type __pos)
788  {
789  // _GLIBCXX_RESOLVE_LIB_DEFECTS
790  // DR60. Do not change _M_gcount.
791  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
792  __try
793  {
794  if (!this->fail())
795  {
796  // 136. seekp, seekg setting wrong streams?
797  const pos_type __p = this->rdbuf()->pubseekpos(__pos,
798  ios_base::in);
799 
800  // 129. Need error indication from seekp() and seekg()
801  if (__p == pos_type(off_type(-1)))
802  __err |= ios_base::failbit;
803  }
804  }
806  {
807  this->_M_setstate(ios_base::badbit);
808  __throw_exception_again;
809  }
810  __catch(...)
811  { this->_M_setstate(ios_base::badbit); }
812  if (__err)
813  this->setstate(__err);
814  return *this;
815  }
816 
817  template<typename _CharT, typename _Traits>
820  seekg(off_type __off, ios_base::seekdir __dir)
821  {
822  // _GLIBCXX_RESOLVE_LIB_DEFECTS
823  // DR60. Do not change _M_gcount.
824  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
825  __try
826  {
827  if (!this->fail())
828  {
829  // 136. seekp, seekg setting wrong streams?
830  const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
831  ios_base::in);
832 
833  // 129. Need error indication from seekp() and seekg()
834  if (__p == pos_type(off_type(-1)))
835  __err |= ios_base::failbit;
836  }
837  }
839  {
840  this->_M_setstate(ios_base::badbit);
841  __throw_exception_again;
842  }
843  __catch(...)
844  { this->_M_setstate(ios_base::badbit); }
845  if (__err)
846  this->setstate(__err);
847  return *this;
848  }
849 
850  // 27.6.1.2.3 Character extraction templates
851  template<typename _CharT, typename _Traits>
854  {
855  typedef basic_istream<_CharT, _Traits> __istream_type;
856  typedef typename __istream_type::int_type __int_type;
857 
858  typename __istream_type::sentry __cerb(__in, false);
859  if (__cerb)
860  {
861  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
862  __try
863  {
864  const __int_type __cb = __in.rdbuf()->sbumpc();
865  if (!_Traits::eq_int_type(__cb, _Traits::eof()))
866  __c = _Traits::to_char_type(__cb);
867  else
868  __err |= (ios_base::eofbit | ios_base::failbit);
869  }
871  {
872  __in._M_setstate(ios_base::badbit);
873  __throw_exception_again;
874  }
875  __catch(...)
876  { __in._M_setstate(ios_base::badbit); }
877  if (__err)
878  __in.setstate(__err);
879  }
880  return __in;
881  }
882 
883  template<typename _CharT, typename _Traits>
884  basic_istream<_CharT, _Traits>&
886  {
887  typedef basic_istream<_CharT, _Traits> __istream_type;
888  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
889  typedef typename _Traits::int_type int_type;
890  typedef _CharT char_type;
891  typedef ctype<_CharT> __ctype_type;
892 
893  streamsize __extracted = 0;
894  ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
895  typename __istream_type::sentry __cerb(__in, false);
896  if (__cerb)
897  {
898  __try
899  {
900  // Figure out how many characters to extract.
901  streamsize __num = __in.width();
902  if (__num <= 0)
903  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
904 
905  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
906 
907  const int_type __eof = _Traits::eof();
908  __streambuf_type* __sb = __in.rdbuf();
909  int_type __c = __sb->sgetc();
910 
911  while (__extracted < __num - 1
912  && !_Traits::eq_int_type(__c, __eof)
913  && !__ct.is(ctype_base::space,
914  _Traits::to_char_type(__c)))
915  {
916  *__s++ = _Traits::to_char_type(__c);
917  ++__extracted;
918  __c = __sb->snextc();
919  }
920  if (_Traits::eq_int_type(__c, __eof))
921  __err |= ios_base::eofbit;
922 
923  // _GLIBCXX_RESOLVE_LIB_DEFECTS
924  // 68. Extractors for char* should store null at end
925  *__s = char_type();
926  __in.width(0);
927  }
929  {
930  __in._M_setstate(ios_base::badbit);
931  __throw_exception_again;
932  }
933  __catch(...)
934  { __in._M_setstate(ios_base::badbit); }
935  }
936  if (!__extracted)
937  __err |= ios_base::failbit;
938  if (__err)
939  __in.setstate(__err);
940  return __in;
941  }
942 
943  // 27.6.1.4 Standard basic_istream manipulators
944  template<typename _CharT, typename _Traits>
945  basic_istream<_CharT, _Traits>&
947  {
948  typedef basic_istream<_CharT, _Traits> __istream_type;
949  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
950  typedef typename __istream_type::int_type __int_type;
951  typedef ctype<_CharT> __ctype_type;
952 
953  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
954  const __int_type __eof = _Traits::eof();
955  __streambuf_type* __sb = __in.rdbuf();
956  __int_type __c = __sb->sgetc();
957 
958  while (!_Traits::eq_int_type(__c, __eof)
959  && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
960  __c = __sb->snextc();
961 
962  if (_Traits::eq_int_type(__c, __eof))
963  __in.setstate(ios_base::eofbit);
964  return __in;
965  }
966 
967  // Inhibit implicit instantiations for required instantiations,
968  // which are defined via explicit instantiations elsewhere.
969  // NB: This syntax is a GNU extension.
970 #if _GLIBCXX_EXTERN_TEMPLATE
971  extern template class basic_istream<char>;
972  extern template istream& ws(istream&);
973  extern template istream& operator>>(istream&, char&);
974  extern template istream& operator>>(istream&, char*);
975  extern template istream& operator>>(istream&, unsigned char&);
976  extern template istream& operator>>(istream&, signed char&);
977  extern template istream& operator>>(istream&, unsigned char*);
978  extern template istream& operator>>(istream&, signed char*);
979 
980  extern template istream& istream::_M_extract(unsigned short&);
981  extern template istream& istream::_M_extract(unsigned int&);
982  extern template istream& istream::_M_extract(long&);
983  extern template istream& istream::_M_extract(unsigned long&);
984  extern template istream& istream::_M_extract(bool&);
985 #ifdef _GLIBCXX_USE_LONG_LONG
986  extern template istream& istream::_M_extract(long long&);
987  extern template istream& istream::_M_extract(unsigned long long&);
988 #endif
989  extern template istream& istream::_M_extract(float&);
990  extern template istream& istream::_M_extract(double&);
991  extern template istream& istream::_M_extract(long double&);
992  extern template istream& istream::_M_extract(void*&);
993 
994  extern template class basic_iostream<char>;
995 
996 #ifdef _GLIBCXX_USE_WCHAR_T
997  extern template class basic_istream<wchar_t>;
998  extern template wistream& ws(wistream&);
999  extern template wistream& operator>>(wistream&, wchar_t&);
1000  extern template wistream& operator>>(wistream&, wchar_t*);
1001 
1002  extern template wistream& wistream::_M_extract(unsigned short&);
1003  extern template wistream& wistream::_M_extract(unsigned int&);
1004  extern template wistream& wistream::_M_extract(long&);
1005  extern template wistream& wistream::_M_extract(unsigned long&);
1006  extern template wistream& wistream::_M_extract(bool&);
1007 #ifdef _GLIBCXX_USE_LONG_LONG
1008  extern template wistream& wistream::_M_extract(long long&);
1009  extern template wistream& wistream::_M_extract(unsigned long long&);
1010 #endif
1011  extern template wistream& wistream::_M_extract(float&);
1012  extern template wistream& wistream::_M_extract(double&);
1013  extern template wistream& wistream::_M_extract(long double&);
1014  extern template wistream& wistream::_M_extract(void*&);
1015 
1016  extern template class basic_iostream<wchar_t>;
1017 #endif
1018 #endif
1019 
1020 _GLIBCXX_END_NAMESPACE
1021 
1022 #endif
ios_base & skipws(ios_base &__base)
Calls base.setf(ios_base::skipws).
Definition: ios_base.h:863
iter_type get(iter_type __in, iter_type __end, ios_base &__io, ios_base::iostate &__err, bool &__v) const
Numeric parsing.
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: bitset:1306
Performs setup work for input streams.
Definition: istream:632
void setstate(iostate __state)
Sets additional flags in the error state.
Definition: basic_ios.h:147
int_type sbumpc()
Getting the next character.
Definition: streambuf:293
The actual work of input and output (interface).
Definition: iosfwd:50
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
Definition: cxxabi-forced.h:41
int_type sungetc()
Moving backwards in the input stream.
Definition: streambuf:373
streamsize width() const
Flags access.
Definition: ios_base.h:648
basic_istream< _CharT, _Traits > & ws(basic_istream< _CharT, _Traits > &__is)
Quick and easy way to eat whitespace.
Definition: istream.tcc:946
bool is(mask __m, char_type __c) const
Test char_type classification.
int_type sgetc()
Getting the next character.
Definition: streambuf:315
basic_istream< char > istream
One of the I/O .
Definition: iosfwd:129
int pubsync()
Entry point for imbue().
Definition: streambuf:248
int_type sputc(char_type __c)
Entry point for all single-character output functions.
Definition: streambuf:400
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.
Definition: basic_ios.h:311
const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:186
basic_istream< wchar_t > wistream
One of the I/O .
Definition: iosfwd:144
Template ctype facet.
int_type sputbackc(char_type __c)
Pushing characters back into the input stream.
Definition: streambuf:348
Controlling input.This is the base class for all input streams. It provides text formatting of all bu...
Definition: iosfwd:53
locale getloc() const
Locale access.
Definition: ios_base.h:699
int_type snextc()
Getting the next character.
Definition: streambuf:275
Facet for parsing number strings.