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