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