libstdc++
istream.tcc
Go to the documentation of this file.
1 // istream classes -*- C++ -*-
2 
3 // Copyright (C) 1997-2014 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>
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  {
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::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  sentry __cerb(*this, false);
119  if (__cerb)
120  {
121  ios_base::iostate __err = ios_base::goodbit;
122  __try
123  {
124  long __l;
125  const __num_get_type& __ng = __check_facet(this->_M_num_get);
126  __ng.get(*this, 0, *this, __err, __l);
127 
128  // _GLIBCXX_RESOLVE_LIB_DEFECTS
129  // 696. istream::operator>>(int&) broken.
130  if (__l < __gnu_cxx::__numeric_traits<short>::__min)
131  {
132  __err |= ios_base::failbit;
133  __n = __gnu_cxx::__numeric_traits<short>::__min;
134  }
135  else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
136  {
137  __err |= ios_base::failbit;
138  __n = __gnu_cxx::__numeric_traits<short>::__max;
139  }
140  else
141  __n = short(__l);
142  }
144  {
145  this->_M_setstate(ios_base::badbit);
146  __throw_exception_again;
147  }
148  __catch(...)
149  { this->_M_setstate(ios_base::badbit); }
150  if (__err)
151  this->setstate(__err);
152  }
153  return *this;
154  }
155 
156  template<typename _CharT, typename _Traits>
159  operator>>(int& __n)
160  {
161  // _GLIBCXX_RESOLVE_LIB_DEFECTS
162  // 118. basic_istream uses nonexistent num_get member functions.
163  sentry __cerb(*this, false);
164  if (__cerb)
165  {
166  ios_base::iostate __err = ios_base::goodbit;
167  __try
168  {
169  long __l;
170  const __num_get_type& __ng = __check_facet(this->_M_num_get);
171  __ng.get(*this, 0, *this, __err, __l);
172 
173  // _GLIBCXX_RESOLVE_LIB_DEFECTS
174  // 696. istream::operator>>(int&) broken.
175  if (__l < __gnu_cxx::__numeric_traits<int>::__min)
176  {
177  __err |= ios_base::failbit;
178  __n = __gnu_cxx::__numeric_traits<int>::__min;
179  }
180  else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
181  {
182  __err |= ios_base::failbit;
183  __n = __gnu_cxx::__numeric_traits<int>::__max;
184  }
185  else
186  __n = int(__l);
187  }
189  {
190  this->_M_setstate(ios_base::badbit);
191  __throw_exception_again;
192  }
193  __catch(...)
194  { this->_M_setstate(ios_base::badbit); }
195  if (__err)
196  this->setstate(__err);
197  }
198  return *this;
199  }
200 
201  template<typename _CharT, typename _Traits>
205  {
206  ios_base::iostate __err = ios_base::goodbit;
207  sentry __cerb(*this, false);
208  if (__cerb && __sbout)
209  {
210  __try
211  {
212  bool __ineof;
213  if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
214  __err |= ios_base::failbit;
215  if (__ineof)
216  __err |= ios_base::eofbit;
217  }
219  {
220  this->_M_setstate(ios_base::failbit);
221  __throw_exception_again;
222  }
223  __catch(...)
224  { this->_M_setstate(ios_base::failbit); }
225  }
226  else if (!__sbout)
227  __err |= ios_base::failbit;
228  if (__err)
229  this->setstate(__err);
230  return *this;
231  }
232 
233  template<typename _CharT, typename _Traits>
234  typename basic_istream<_CharT, _Traits>::int_type
236  get(void)
237  {
238  const int_type __eof = traits_type::eof();
239  int_type __c = __eof;
240  _M_gcount = 0;
241  ios_base::iostate __err = ios_base::goodbit;
242  sentry __cerb(*this, true);
243  if (__cerb)
244  {
245  __try
246  {
247  __c = this->rdbuf()->sbumpc();
248  // 27.6.1.1 paragraph 3
249  if (!traits_type::eq_int_type(__c, __eof))
250  _M_gcount = 1;
251  else
252  __err |= ios_base::eofbit;
253  }
255  {
256  this->_M_setstate(ios_base::badbit);
257  __throw_exception_again;
258  }
259  __catch(...)
260  { this->_M_setstate(ios_base::badbit); }
261  }
262  if (!_M_gcount)
263  __err |= ios_base::failbit;
264  if (__err)
265  this->setstate(__err);
266  return __c;
267  }
268 
269  template<typename _CharT, typename _Traits>
272  get(char_type& __c)
273  {
274  _M_gcount = 0;
275  ios_base::iostate __err = ios_base::goodbit;
276  sentry __cerb(*this, true);
277  if (__cerb)
278  {
279  __try
280  {
281  const int_type __cb = this->rdbuf()->sbumpc();
282  // 27.6.1.1 paragraph 3
283  if (!traits_type::eq_int_type(__cb, traits_type::eof()))
284  {
285  _M_gcount = 1;
286  __c = traits_type::to_char_type(__cb);
287  }
288  else
289  __err |= ios_base::eofbit;
290  }
292  {
293  this->_M_setstate(ios_base::badbit);
294  __throw_exception_again;
295  }
296  __catch(...)
297  { this->_M_setstate(ios_base::badbit); }
298  }
299  if (!_M_gcount)
300  __err |= ios_base::failbit;
301  if (__err)
302  this->setstate(__err);
303  return *this;
304  }
305 
306  template<typename _CharT, typename _Traits>
309  get(char_type* __s, streamsize __n, char_type __delim)
310  {
311  _M_gcount = 0;
312  ios_base::iostate __err = ios_base::goodbit;
313  sentry __cerb(*this, true);
314  if (__cerb)
315  {
316  __try
317  {
318  const int_type __idelim = traits_type::to_int_type(__delim);
319  const int_type __eof = traits_type::eof();
320  __streambuf_type* __sb = this->rdbuf();
321  int_type __c = __sb->sgetc();
322 
323  while (_M_gcount + 1 < __n
324  && !traits_type::eq_int_type(__c, __eof)
325  && !traits_type::eq_int_type(__c, __idelim))
326  {
327  *__s++ = traits_type::to_char_type(__c);
328  ++_M_gcount;
329  __c = __sb->snextc();
330  }
331  if (traits_type::eq_int_type(__c, __eof))
332  __err |= ios_base::eofbit;
333  }
335  {
336  this->_M_setstate(ios_base::badbit);
337  __throw_exception_again;
338  }
339  __catch(...)
340  { this->_M_setstate(ios_base::badbit); }
341  }
342  // _GLIBCXX_RESOLVE_LIB_DEFECTS
343  // 243. get and getline when sentry reports failure.
344  if (__n > 0)
345  *__s = char_type();
346  if (!_M_gcount)
347  __err |= ios_base::failbit;
348  if (__err)
349  this->setstate(__err);
350  return *this;
351  }
352 
353  template<typename _CharT, typename _Traits>
356  get(__streambuf_type& __sb, char_type __delim)
357  {
358  _M_gcount = 0;
359  ios_base::iostate __err = ios_base::goodbit;
360  sentry __cerb(*this, true);
361  if (__cerb)
362  {
363  __try
364  {
365  const int_type __idelim = traits_type::to_int_type(__delim);
366  const int_type __eof = traits_type::eof();
367  __streambuf_type* __this_sb = this->rdbuf();
368  int_type __c = __this_sb->sgetc();
369  char_type __c2 = traits_type::to_char_type(__c);
370 
371  while (!traits_type::eq_int_type(__c, __eof)
372  && !traits_type::eq_int_type(__c, __idelim)
373  && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
374  {
375  ++_M_gcount;
376  __c = __this_sb->snextc();
377  __c2 = traits_type::to_char_type(__c);
378  }
379  if (traits_type::eq_int_type(__c, __eof))
380  __err |= ios_base::eofbit;
381  }
383  {
384  this->_M_setstate(ios_base::badbit);
385  __throw_exception_again;
386  }
387  __catch(...)
388  { this->_M_setstate(ios_base::badbit); }
389  }
390  if (!_M_gcount)
391  __err |= ios_base::failbit;
392  if (__err)
393  this->setstate(__err);
394  return *this;
395  }
396 
397  template<typename _CharT, typename _Traits>
400  getline(char_type* __s, streamsize __n, char_type __delim)
401  {
402  _M_gcount = 0;
403  ios_base::iostate __err = ios_base::goodbit;
404  sentry __cerb(*this, true);
405  if (__cerb)
406  {
407  __try
408  {
409  const int_type __idelim = traits_type::to_int_type(__delim);
410  const int_type __eof = traits_type::eof();
411  __streambuf_type* __sb = this->rdbuf();
412  int_type __c = __sb->sgetc();
413 
414  while (_M_gcount + 1 < __n
415  && !traits_type::eq_int_type(__c, __eof)
416  && !traits_type::eq_int_type(__c, __idelim))
417  {
418  *__s++ = traits_type::to_char_type(__c);
419  __c = __sb->snextc();
420  ++_M_gcount;
421  }
422  if (traits_type::eq_int_type(__c, __eof))
423  __err |= ios_base::eofbit;
424  else
425  {
426  if (traits_type::eq_int_type(__c, __idelim))
427  {
428  __sb->sbumpc();
429  ++_M_gcount;
430  }
431  else
432  __err |= ios_base::failbit;
433  }
434  }
436  {
437  this->_M_setstate(ios_base::badbit);
438  __throw_exception_again;
439  }
440  __catch(...)
441  { this->_M_setstate(ios_base::badbit); }
442  }
443  // _GLIBCXX_RESOLVE_LIB_DEFECTS
444  // 243. get and getline when sentry reports failure.
445  if (__n > 0)
446  *__s = char_type();
447  if (!_M_gcount)
448  __err |= ios_base::failbit;
449  if (__err)
450  this->setstate(__err);
451  return *this;
452  }
453 
454  // We provide three overloads, since the first two are much simpler
455  // than the general case. Also, the latter two can thus adopt the
456  // same "batchy" strategy used by getline above.
457  template<typename _CharT, typename _Traits>
460  ignore(void)
461  {
462  _M_gcount = 0;
463  sentry __cerb(*this, true);
464  if (__cerb)
465  {
466  ios_base::iostate __err = ios_base::goodbit;
467  __try
468  {
469  const int_type __eof = traits_type::eof();
470  __streambuf_type* __sb = this->rdbuf();
471 
472  if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
473  __err |= ios_base::eofbit;
474  else
475  _M_gcount = 1;
476  }
478  {
479  this->_M_setstate(ios_base::badbit);
480  __throw_exception_again;
481  }
482  __catch(...)
483  { this->_M_setstate(ios_base::badbit); }
484  if (__err)
485  this->setstate(__err);
486  }
487  return *this;
488  }
489 
490  template<typename _CharT, typename _Traits>
494  {
495  _M_gcount = 0;
496  sentry __cerb(*this, true);
497  if (__cerb && __n > 0)
498  {
499  ios_base::iostate __err = ios_base::goodbit;
500  __try
501  {
502  const int_type __eof = traits_type::eof();
503  __streambuf_type* __sb = this->rdbuf();
504  int_type __c = __sb->sgetc();
505 
506  // N.B. On LFS-enabled platforms streamsize is still 32 bits
507  // wide: if we want to implement the standard mandated behavior
508  // for n == max() (see 27.6.1.3/24) we are at risk of signed
509  // integer overflow: thus these contortions. Also note that,
510  // by definition, when more than 2G chars are actually ignored,
511  // _M_gcount (the return value of gcount, that is) cannot be
512  // really correct, being unavoidably too small.
513  bool __large_ignore = false;
514  while (true)
515  {
516  while (_M_gcount < __n
517  && !traits_type::eq_int_type(__c, __eof))
518  {
519  ++_M_gcount;
520  __c = __sb->snextc();
521  }
522  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
523  && !traits_type::eq_int_type(__c, __eof))
524  {
525  _M_gcount =
526  __gnu_cxx::__numeric_traits<streamsize>::__min;
527  __large_ignore = true;
528  }
529  else
530  break;
531  }
532 
533  if (__large_ignore)
534  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
535 
536  if (traits_type::eq_int_type(__c, __eof))
537  __err |= ios_base::eofbit;
538  }
540  {
541  this->_M_setstate(ios_base::badbit);
542  __throw_exception_again;
543  }
544  __catch(...)
545  { this->_M_setstate(ios_base::badbit); }
546  if (__err)
547  this->setstate(__err);
548  }
549  return *this;
550  }
551 
552  template<typename _CharT, typename _Traits>
555  ignore(streamsize __n, int_type __delim)
556  {
557  _M_gcount = 0;
558  sentry __cerb(*this, true);
559  if (__cerb && __n > 0)
560  {
561  ios_base::iostate __err = ios_base::goodbit;
562  __try
563  {
564  const int_type __eof = traits_type::eof();
565  __streambuf_type* __sb = this->rdbuf();
566  int_type __c = __sb->sgetc();
567 
568  // See comment above.
569  bool __large_ignore = false;
570  while (true)
571  {
572  while (_M_gcount < __n
573  && !traits_type::eq_int_type(__c, __eof)
574  && !traits_type::eq_int_type(__c, __delim))
575  {
576  ++_M_gcount;
577  __c = __sb->snextc();
578  }
579  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
580  && !traits_type::eq_int_type(__c, __eof)
581  && !traits_type::eq_int_type(__c, __delim))
582  {
583  _M_gcount =
584  __gnu_cxx::__numeric_traits<streamsize>::__min;
585  __large_ignore = true;
586  }
587  else
588  break;
589  }
590 
591  if (__large_ignore)
592  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
593 
594  if (traits_type::eq_int_type(__c, __eof))
595  __err |= ios_base::eofbit;
596  else if (traits_type::eq_int_type(__c, __delim))
597  {
598  if (_M_gcount
599  < __gnu_cxx::__numeric_traits<streamsize>::__max)
600  ++_M_gcount;
601  __sb->sbumpc();
602  }
603  }
605  {
606  this->_M_setstate(ios_base::badbit);
607  __throw_exception_again;
608  }
609  __catch(...)
610  { this->_M_setstate(ios_base::badbit); }
611  if (__err)
612  this->setstate(__err);
613  }
614  return *this;
615  }
616 
617  template<typename _CharT, typename _Traits>
618  typename basic_istream<_CharT, _Traits>::int_type
620  peek(void)
621  {
622  int_type __c = traits_type::eof();
623  _M_gcount = 0;
624  sentry __cerb(*this, true);
625  if (__cerb)
626  {
627  ios_base::iostate __err = ios_base::goodbit;
628  __try
629  {
630  __c = this->rdbuf()->sgetc();
631  if (traits_type::eq_int_type(__c, traits_type::eof()))
632  __err |= ios_base::eofbit;
633  }
635  {
636  this->_M_setstate(ios_base::badbit);
637  __throw_exception_again;
638  }
639  __catch(...)
640  { this->_M_setstate(ios_base::badbit); }
641  if (__err)
642  this->setstate(__err);
643  }
644  return __c;
645  }
646 
647  template<typename _CharT, typename _Traits>
650  read(char_type* __s, streamsize __n)
651  {
652  _M_gcount = 0;
653  sentry __cerb(*this, true);
654  if (__cerb)
655  {
656  ios_base::iostate __err = ios_base::goodbit;
657  __try
658  {
659  _M_gcount = this->rdbuf()->sgetn(__s, __n);
660  if (_M_gcount != __n)
661  __err |= (ios_base::eofbit | ios_base::failbit);
662  }
664  {
665  this->_M_setstate(ios_base::badbit);
666  __throw_exception_again;
667  }
668  __catch(...)
669  { this->_M_setstate(ios_base::badbit); }
670  if (__err)
671  this->setstate(__err);
672  }
673  return *this;
674  }
675 
676  template<typename _CharT, typename _Traits>
677  streamsize
679  readsome(char_type* __s, streamsize __n)
680  {
681  _M_gcount = 0;
682  sentry __cerb(*this, true);
683  if (__cerb)
684  {
685  ios_base::iostate __err = ios_base::goodbit;
686  __try
687  {
688  // Cannot compare int_type with streamsize generically.
689  const streamsize __num = this->rdbuf()->in_avail();
690  if (__num > 0)
691  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
692  else if (__num == -1)
693  __err |= ios_base::eofbit;
694  }
696  {
697  this->_M_setstate(ios_base::badbit);
698  __throw_exception_again;
699  }
700  __catch(...)
701  { this->_M_setstate(ios_base::badbit); }
702  if (__err)
703  this->setstate(__err);
704  }
705  return _M_gcount;
706  }
707 
708  template<typename _CharT, typename _Traits>
711  putback(char_type __c)
712  {
713  // _GLIBCXX_RESOLVE_LIB_DEFECTS
714  // 60. What is a formatted input function?
715  _M_gcount = 0;
716  // Clear eofbit per N3168.
717  this->clear(this->rdstate() & ~ios_base::eofbit);
718  sentry __cerb(*this, true);
719  if (__cerb)
720  {
721  ios_base::iostate __err = ios_base::goodbit;
722  __try
723  {
724  const int_type __eof = traits_type::eof();
725  __streambuf_type* __sb = this->rdbuf();
726  if (!__sb
727  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
728  __err |= ios_base::badbit;
729  }
731  {
732  this->_M_setstate(ios_base::badbit);
733  __throw_exception_again;
734  }
735  __catch(...)
736  { this->_M_setstate(ios_base::badbit); }
737  if (__err)
738  this->setstate(__err);
739  }
740  return *this;
741  }
742 
743  template<typename _CharT, typename _Traits>
746  unget(void)
747  {
748  // _GLIBCXX_RESOLVE_LIB_DEFECTS
749  // 60. What is a formatted input function?
750  _M_gcount = 0;
751  // Clear eofbit per N3168.
752  this->clear(this->rdstate() & ~ios_base::eofbit);
753  sentry __cerb(*this, true);
754  if (__cerb)
755  {
756  ios_base::iostate __err = ios_base::goodbit;
757  __try
758  {
759  const int_type __eof = traits_type::eof();
760  __streambuf_type* __sb = this->rdbuf();
761  if (!__sb
762  || traits_type::eq_int_type(__sb->sungetc(), __eof))
763  __err |= ios_base::badbit;
764  }
766  {
767  this->_M_setstate(ios_base::badbit);
768  __throw_exception_again;
769  }
770  __catch(...)
771  { this->_M_setstate(ios_base::badbit); }
772  if (__err)
773  this->setstate(__err);
774  }
775  return *this;
776  }
777 
778  template<typename _CharT, typename _Traits>
779  int
781  sync(void)
782  {
783  // _GLIBCXX_RESOLVE_LIB_DEFECTS
784  // DR60. Do not change _M_gcount.
785  int __ret = -1;
786  sentry __cerb(*this, true);
787  if (__cerb)
788  {
789  ios_base::iostate __err = ios_base::goodbit;
790  __try
791  {
792  __streambuf_type* __sb = this->rdbuf();
793  if (__sb)
794  {
795  if (__sb->pubsync() == -1)
796  __err |= ios_base::badbit;
797  else
798  __ret = 0;
799  }
800  }
802  {
803  this->_M_setstate(ios_base::badbit);
804  __throw_exception_again;
805  }
806  __catch(...)
807  { this->_M_setstate(ios_base::badbit); }
808  if (__err)
809  this->setstate(__err);
810  }
811  return __ret;
812  }
813 
814  template<typename _CharT, typename _Traits>
815  typename basic_istream<_CharT, _Traits>::pos_type
817  tellg(void)
818  {
819  // _GLIBCXX_RESOLVE_LIB_DEFECTS
820  // DR60. Do not change _M_gcount.
821  pos_type __ret = pos_type(-1);
822  sentry __cerb(*this, true);
823  if (__cerb)
824  {
825  __try
826  {
827  if (!this->fail())
828  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
829  ios_base::in);
830  }
832  {
833  this->_M_setstate(ios_base::badbit);
834  __throw_exception_again;
835  }
836  __catch(...)
837  { this->_M_setstate(ios_base::badbit); }
838  }
839  return __ret;
840  }
841 
842  template<typename _CharT, typename _Traits>
845  seekg(pos_type __pos)
846  {
847  // _GLIBCXX_RESOLVE_LIB_DEFECTS
848  // DR60. Do not change _M_gcount.
849  // Clear eofbit per N3168.
850  this->clear(this->rdstate() & ~ios_base::eofbit);
851  sentry __cerb(*this, true);
852  if (__cerb)
853  {
854  ios_base::iostate __err = ios_base::goodbit;
855  __try
856  {
857  if (!this->fail())
858  {
859  // 136. seekp, seekg setting wrong streams?
860  const pos_type __p = this->rdbuf()->pubseekpos(__pos,
861  ios_base::in);
862 
863  // 129. Need error indication from seekp() and seekg()
864  if (__p == pos_type(off_type(-1)))
865  __err |= ios_base::failbit;
866  }
867  }
869  {
870  this->_M_setstate(ios_base::badbit);
871  __throw_exception_again;
872  }
873  __catch(...)
874  { this->_M_setstate(ios_base::badbit); }
875  if (__err)
876  this->setstate(__err);
877  }
878  return *this;
879  }
880 
881  template<typename _CharT, typename _Traits>
884  seekg(off_type __off, ios_base::seekdir __dir)
885  {
886  // _GLIBCXX_RESOLVE_LIB_DEFECTS
887  // DR60. Do not change _M_gcount.
888  // Clear eofbit per N3168.
889  this->clear(this->rdstate() & ~ios_base::eofbit);
890  sentry __cerb(*this, true);
891  if (__cerb)
892  {
893  ios_base::iostate __err = ios_base::goodbit;
894  __try
895  {
896  if (!this->fail())
897  {
898  // 136. seekp, seekg setting wrong streams?
899  const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
900  ios_base::in);
901 
902  // 129. Need error indication from seekp() and seekg()
903  if (__p == pos_type(off_type(-1)))
904  __err |= ios_base::failbit;
905  }
906  }
908  {
909  this->_M_setstate(ios_base::badbit);
910  __throw_exception_again;
911  }
912  __catch(...)
913  { this->_M_setstate(ios_base::badbit); }
914  if (__err)
915  this->setstate(__err);
916  }
917  return *this;
918  }
919 
920  // 27.6.1.2.3 Character extraction templates
921  template<typename _CharT, typename _Traits>
924  {
925  typedef basic_istream<_CharT, _Traits> __istream_type;
926  typedef typename __istream_type::int_type __int_type;
927 
928  typename __istream_type::sentry __cerb(__in, false);
929  if (__cerb)
930  {
931  ios_base::iostate __err = ios_base::goodbit;
932  __try
933  {
934  const __int_type __cb = __in.rdbuf()->sbumpc();
935  if (!_Traits::eq_int_type(__cb, _Traits::eof()))
936  __c = _Traits::to_char_type(__cb);
937  else
938  __err |= (ios_base::eofbit | ios_base::failbit);
939  }
941  {
942  __in._M_setstate(ios_base::badbit);
943  __throw_exception_again;
944  }
945  __catch(...)
946  { __in._M_setstate(ios_base::badbit); }
947  if (__err)
948  __in.setstate(__err);
949  }
950  return __in;
951  }
952 
953  template<typename _CharT, typename _Traits>
954  basic_istream<_CharT, _Traits>&
956  {
957  typedef basic_istream<_CharT, _Traits> __istream_type;
958  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
959  typedef typename _Traits::int_type int_type;
960  typedef _CharT char_type;
961  typedef ctype<_CharT> __ctype_type;
962 
963  streamsize __extracted = 0;
964  ios_base::iostate __err = ios_base::goodbit;
965  typename __istream_type::sentry __cerb(__in, false);
966  if (__cerb)
967  {
968  __try
969  {
970  // Figure out how many characters to extract.
971  streamsize __num = __in.width();
972  if (__num <= 0)
973  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
974 
975  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
976 
977  const int_type __eof = _Traits::eof();
978  __streambuf_type* __sb = __in.rdbuf();
979  int_type __c = __sb->sgetc();
980 
981  while (__extracted < __num - 1
982  && !_Traits::eq_int_type(__c, __eof)
983  && !__ct.is(ctype_base::space,
984  _Traits::to_char_type(__c)))
985  {
986  *__s++ = _Traits::to_char_type(__c);
987  ++__extracted;
988  __c = __sb->snextc();
989  }
990  if (_Traits::eq_int_type(__c, __eof))
991  __err |= ios_base::eofbit;
992 
993  // _GLIBCXX_RESOLVE_LIB_DEFECTS
994  // 68. Extractors for char* should store null at end
995  *__s = char_type();
996  __in.width(0);
997  }
999  {
1000  __in._M_setstate(ios_base::badbit);
1001  __throw_exception_again;
1002  }
1003  __catch(...)
1004  { __in._M_setstate(ios_base::badbit); }
1005  }
1006  if (!__extracted)
1007  __err |= ios_base::failbit;
1008  if (__err)
1009  __in.setstate(__err);
1010  return __in;
1011  }
1012 
1013  // 27.6.1.4 Standard basic_istream manipulators
1014  template<typename _CharT, typename _Traits>
1015  basic_istream<_CharT, _Traits>&
1017  {
1018  typedef basic_istream<_CharT, _Traits> __istream_type;
1019  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
1020  typedef typename __istream_type::int_type __int_type;
1021  typedef ctype<_CharT> __ctype_type;
1022 
1023  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1024  const __int_type __eof = _Traits::eof();
1025  __streambuf_type* __sb = __in.rdbuf();
1026  __int_type __c = __sb->sgetc();
1027 
1028  while (!_Traits::eq_int_type(__c, __eof)
1029  && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1030  __c = __sb->snextc();
1031 
1032  if (_Traits::eq_int_type(__c, __eof))
1033  __in.setstate(ios_base::eofbit);
1034  return __in;
1035  }
1036 
1037  // Inhibit implicit instantiations for required instantiations,
1038  // which are defined via explicit instantiations elsewhere.
1039 #if _GLIBCXX_EXTERN_TEMPLATE
1040  extern template class basic_istream<char>;
1041  extern template istream& ws(istream&);
1042  extern template istream& operator>>(istream&, char&);
1043  extern template istream& operator>>(istream&, char*);
1044  extern template istream& operator>>(istream&, unsigned char&);
1045  extern template istream& operator>>(istream&, signed char&);
1046  extern template istream& operator>>(istream&, unsigned char*);
1047  extern template istream& operator>>(istream&, signed char*);
1048 
1049  extern template istream& istream::_M_extract(unsigned short&);
1050  extern template istream& istream::_M_extract(unsigned int&);
1051  extern template istream& istream::_M_extract(long&);
1052  extern template istream& istream::_M_extract(unsigned long&);
1053  extern template istream& istream::_M_extract(bool&);
1054 #ifdef _GLIBCXX_USE_LONG_LONG
1055  extern template istream& istream::_M_extract(long long&);
1056  extern template istream& istream::_M_extract(unsigned long long&);
1057 #endif
1058  extern template istream& istream::_M_extract(float&);
1059  extern template istream& istream::_M_extract(double&);
1060  extern template istream& istream::_M_extract(long double&);
1061  extern template istream& istream::_M_extract(void*&);
1062 
1063  extern template class basic_iostream<char>;
1064 
1065 #ifdef _GLIBCXX_USE_WCHAR_T
1066  extern template class basic_istream<wchar_t>;
1067  extern template wistream& ws(wistream&);
1068  extern template wistream& operator>>(wistream&, wchar_t&);
1069  extern template wistream& operator>>(wistream&, wchar_t*);
1070 
1071  extern template wistream& wistream::_M_extract(unsigned short&);
1072  extern template wistream& wistream::_M_extract(unsigned int&);
1073  extern template wistream& wistream::_M_extract(long&);
1074  extern template wistream& wistream::_M_extract(unsigned long&);
1075  extern template wistream& wistream::_M_extract(bool&);
1076 #ifdef _GLIBCXX_USE_LONG_LONG
1077  extern template wistream& wistream::_M_extract(long long&);
1078  extern template wistream& wistream::_M_extract(unsigned long long&);
1079 #endif
1080  extern template wistream& wistream::_M_extract(float&);
1081  extern template wistream& wistream::_M_extract(double&);
1082  extern template wistream& wistream::_M_extract(long double&);
1083  extern template wistream& wistream::_M_extract(void*&);
1084 
1085  extern template class basic_iostream<wchar_t>;
1086 #endif
1087 #endif
1088 
1089 _GLIBCXX_END_NAMESPACE_VERSION
1090 } // namespace std
1091 
1092 #endif
__istream_type & unget()
Unextracting the previous character.
Definition: istream.tcc:746
bool good() const
Fast error checking.
Definition: basic_ios.h:174
streamsize _M_gcount
Definition: istream:82
bool is(mask __m, char_type __c) const
Test char_type classification.
Primary class template ctype facet.This template class defines classification and conversion function...
static const iostate failbit
Indicates that an input operation failed to read the expected characters, or that an output operation...
Definition: ios_base.h:342
Performs setup work for input streams.
Definition: istream:657
int_type snextc()
Getting the next character.
Definition: streambuf:298
bool fail() const
Fast error checking.
Definition: basic_ios.h:195
basic_istream< wchar_t > wistream
Base class for wchar_t input streams.
Definition: iosfwd:173
int_type sgetc()
Getting the next character.
Definition: streambuf:338
basic_istream< _CharT, _Traits > & ws(basic_istream< _CharT, _Traits > &__is)
Quick and easy way to eat whitespace.
Definition: istream.tcc:1016
__istream_type & seekg(pos_type)
Changing the current read position.
Definition: istream.tcc:845
Template class basic_istream.
Definition: iosfwd:83
static const openmode in
Open for input. Default for ifstream and fstream.
Definition: ios_base.h:375
static const iostate goodbit
Indicates all is well.
Definition: ios_base.h:345
locale getloc() const
Locale access.
Definition: ios_base.h:695
static const iostate badbit
Indicates a loss of integrity in an input or output sequence (such as an irrecoverable read error fro...
Definition: ios_base.h:334
static const seekdir cur
Request a seek relative to the current position within the sequence.
Definition: ios_base.h:399
basic_istream< char > istream
Base class for char input streams.
Definition: iosfwd:133
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.
Definition: basic_ios.h:315
__istream_type & getline(char_type *__s, streamsize __n, char_type __delim)
String extraction.
Definition: istream.tcc:400
void clear(iostate __state=goodbit)
[Re]sets the error state.
Definition: basic_ios.tcc:41
int_type get()
Simple extraction.
Definition: istream.tcc:236
static const fmtflags skipws
Skips leading white space before certain input operations.
Definition: ios_base.h:300
__istream_type & read(char_type *__s, streamsize __n)
Extraction without delimiters.
Definition: istream.tcc:650
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
Definition: cxxabi_forced.h:48
const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:194
pos_type tellg()
Getting the current read position.
Definition: istream.tcc:817
__istream_type & ignore()
Simple extraction.
Definition: istream.tcc:460
The actual work of input and output (interface).
Definition: iosfwd:80
int_type sbumpc()
Getting the next character.
Definition: streambuf:316
void setstate(iostate __state)
Sets additional flags in the error state.
Definition: basic_ios.h:151
__istream_type & putback(char_type __c)
Unextracting a single character.
Definition: istream.tcc:711
int pubsync()
Calls virtual sync function.
Definition: streambuf:271
int_type sputbackc(char_type __c)
Pushing characters back into the input stream.
Definition: streambuf:372
basic_ostream< _CharT, _Traits > * tie() const
Fetches the current tied stream.
Definition: basic_ios.h:289
int_type peek()
Looking ahead in the stream.
Definition: istream.tcc:620
__istream_type & operator>>(__istream_type &(*__pf)(__istream_type &))
Interface for manipulators.
Definition: istream:120
static const iostate eofbit
Indicates that an input operation reached the end of an input sequence.
Definition: ios_base.h:337
fmtflags flags() const
Access to format flags.
Definition: ios_base.h:551
streamsize width() const
Flags access.
Definition: ios_base.h:644
Primary class template num_get.This facet encapsulates the code to parse and return a number from a s...
iostate rdstate() const
Returns the error state of the stream buffer.
Definition: basic_ios.h:131
int_type sputc(char_type __c)
Entry point for all single-character output functions.
Definition: streambuf:424
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
int sync()
Synchronizing the stream buffer.
Definition: istream.tcc:781
int_type sungetc()
Moving backwards in the input stream.
Definition: streambuf:397
sentry(basic_istream< _CharT, _Traits > &__is, bool __noskipws=false)
The constructor performs all the work.
Definition: istream.tcc:47
streamsize readsome(char_type *__s, streamsize __n)
Extraction until the buffer is exhausted, but no more.
Definition: istream.tcc:679
iter_type get(iter_type __in, iter_type __end, ios_base &__io, ios_base::iostate &__err, bool &__v) const
Numeric parsing.