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>
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  }
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>
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  }
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>&
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  }
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>
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  }
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>
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  }
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
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  }
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>
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  }
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>
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  }
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>
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  unsigned long long __gcount = 0;
396 
397  while (!traits_type::eq_int_type(__c, __eof)
398  && !traits_type::eq_int_type(__c, __idelim)
399  && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
400  {
401  ++__gcount;
402  __c = __this_sb->snextc();
403  __c2 = traits_type::to_char_type(__c);
404  }
405  if (traits_type::eq_int_type(__c, __eof))
406  __err |= ios_base::eofbit;
407  // _GLIBCXX_RESOLVE_LIB_DEFECTS
408  // 3464. istream::gcount() can overflow
409  if (__gcount <= __gnu_cxx::__numeric_traits<streamsize>::__max)
410  _M_gcount = __gcount;
411  else
412  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
413  }
415  {
416  this->_M_setstate(ios_base::badbit);
417  __throw_exception_again;
418  }
419  __catch(...)
420  { this->_M_setstate(ios_base::badbit); }
421  }
422  if (!_M_gcount)
423  __err |= ios_base::failbit;
424  if (__err)
425  this->setstate(__err);
426  return *this;
427  }
428 
429  template<typename _CharT, typename _Traits>
433  {
434  _M_gcount = 0;
435  ios_base::iostate __err = ios_base::goodbit;
436  sentry __cerb(*this, true);
437  if (__cerb)
438  {
439  __try
440  {
441  const int_type __idelim = traits_type::to_int_type(__delim);
442  const int_type __eof = traits_type::eof();
443  __streambuf_type* __sb = this->rdbuf();
444  int_type __c = __sb->sgetc();
445 
446  while (_M_gcount + 1 < __n
447  && !traits_type::eq_int_type(__c, __eof)
448  && !traits_type::eq_int_type(__c, __idelim))
449  {
450  *__s++ = traits_type::to_char_type(__c);
451  __c = __sb->snextc();
452  ++_M_gcount;
453  }
454  if (traits_type::eq_int_type(__c, __eof))
455  __err |= ios_base::eofbit;
456  else
457  {
458  if (traits_type::eq_int_type(__c, __idelim))
459  {
460  __sb->sbumpc();
461  ++_M_gcount;
462  }
463  else
464  __err |= ios_base::failbit;
465  }
466  }
468  {
469  this->_M_setstate(ios_base::badbit);
470  __throw_exception_again;
471  }
472  __catch(...)
473  { this->_M_setstate(ios_base::badbit); }
474  }
475  // _GLIBCXX_RESOLVE_LIB_DEFECTS
476  // 243. get and getline when sentry reports failure.
477  if (__n > 0)
478  *__s = char_type();
479  if (!_M_gcount)
480  __err |= ios_base::failbit;
481  if (__err)
482  this->setstate(__err);
483  return *this;
484  }
485 
486  // We provide three overloads, since the first two are much simpler
487  // than the general case. Also, the latter two can thus adopt the
488  // same "batchy" strategy used by getline above.
489  template<typename _CharT, typename _Traits>
492  ignore(void)
493  {
494  _M_gcount = 0;
495  sentry __cerb(*this, true);
496  if (__cerb)
497  {
498  ios_base::iostate __err = ios_base::goodbit;
499  __try
500  {
501  const int_type __eof = traits_type::eof();
502  __streambuf_type* __sb = this->rdbuf();
503 
504  if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
505  __err |= ios_base::eofbit;
506  else
507  _M_gcount = 1;
508  }
510  {
511  this->_M_setstate(ios_base::badbit);
512  __throw_exception_again;
513  }
514  __catch(...)
515  { this->_M_setstate(ios_base::badbit); }
516  if (__err)
517  this->setstate(__err);
518  }
519  return *this;
520  }
521 
522  template<typename _CharT, typename _Traits>
526  {
527  _M_gcount = 0;
528  sentry __cerb(*this, true);
529  if (__cerb && __n > 0)
530  {
531  ios_base::iostate __err = ios_base::goodbit;
532  __try
533  {
534  const int_type __eof = traits_type::eof();
535  __streambuf_type* __sb = this->rdbuf();
536  int_type __c = __sb->sgetc();
537 
538  // N.B. On LFS-enabled platforms streamsize is still 32 bits
539  // wide: if we want to implement the standard mandated behavior
540  // for n == max() (see 27.6.1.3/24) we are at risk of signed
541  // integer overflow: thus these contortions. Also note that,
542  // by definition, when more than 2G chars are actually ignored,
543  // _M_gcount (the return value of gcount, that is) cannot be
544  // really correct, being unavoidably too small.
545  bool __large_ignore = false;
546  while (true)
547  {
548  while (_M_gcount < __n
549  && !traits_type::eq_int_type(__c, __eof))
550  {
551  ++_M_gcount;
552  __c = __sb->snextc();
553  }
554  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
555  && !traits_type::eq_int_type(__c, __eof))
556  {
557  _M_gcount =
558  __gnu_cxx::__numeric_traits<streamsize>::__min;
559  __large_ignore = true;
560  }
561  else
562  break;
563  }
564 
565  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
566  {
567  if (__large_ignore)
568  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
569 
570  if (traits_type::eq_int_type(__c, __eof))
571  __err |= ios_base::eofbit;
572  }
573  else if (_M_gcount < __n)
574  {
575  if (traits_type::eq_int_type(__c, __eof))
576  __err |= ios_base::eofbit;
577  }
578  }
580  {
581  this->_M_setstate(ios_base::badbit);
582  __throw_exception_again;
583  }
584  __catch(...)
585  { this->_M_setstate(ios_base::badbit); }
586  if (__err)
587  this->setstate(__err);
588  }
589  return *this;
590  }
591 
592  template<typename _CharT, typename _Traits>
596  {
597  _M_gcount = 0;
598  sentry __cerb(*this, true);
599  if (__cerb && __n > 0)
600  {
601  ios_base::iostate __err = ios_base::goodbit;
602  __try
603  {
604  const int_type __eof = traits_type::eof();
605  __streambuf_type* __sb = this->rdbuf();
606  int_type __c = __sb->sgetc();
607 
608  // See comment above.
609  bool __large_ignore = false;
610  while (true)
611  {
612  while (_M_gcount < __n
613  && !traits_type::eq_int_type(__c, __eof)
614  && !traits_type::eq_int_type(__c, __delim))
615  {
616  ++_M_gcount;
617  __c = __sb->snextc();
618  }
619  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
620  && !traits_type::eq_int_type(__c, __eof)
621  && !traits_type::eq_int_type(__c, __delim))
622  {
623  _M_gcount =
624  __gnu_cxx::__numeric_traits<streamsize>::__min;
625  __large_ignore = true;
626  }
627  else
628  break;
629  }
630 
631  if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
632  {
633  if (__large_ignore)
634  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
635 
636  if (traits_type::eq_int_type(__c, __eof))
637  __err |= ios_base::eofbit;
638  else
639  {
640  if (_M_gcount != __n)
641  ++_M_gcount;
642  __sb->sbumpc();
643  }
644  }
645  else if (_M_gcount < __n) // implies __c == __delim or EOF
646  {
647  if (traits_type::eq_int_type(__c, __eof))
648  __err |= ios_base::eofbit;
649  else
650  {
651  ++_M_gcount;
652  __sb->sbumpc();
653  }
654  }
655  }
657  {
658  this->_M_setstate(ios_base::badbit);
659  __throw_exception_again;
660  }
661  __catch(...)
662  { this->_M_setstate(ios_base::badbit); }
663  if (__err)
664  this->setstate(__err);
665  }
666  return *this;
667  }
668 
669  template<typename _CharT, typename _Traits>
670  typename basic_istream<_CharT, _Traits>::int_type
672  peek(void)
673  {
674  int_type __c = traits_type::eof();
675  _M_gcount = 0;
676  sentry __cerb(*this, true);
677  if (__cerb)
678  {
679  ios_base::iostate __err = ios_base::goodbit;
680  __try
681  {
682  __c = this->rdbuf()->sgetc();
683  if (traits_type::eq_int_type(__c, traits_type::eof()))
684  __err |= ios_base::eofbit;
685  }
687  {
688  this->_M_setstate(ios_base::badbit);
689  __throw_exception_again;
690  }
691  __catch(...)
692  { this->_M_setstate(ios_base::badbit); }
693  if (__err)
694  this->setstate(__err);
695  }
696  return __c;
697  }
698 
699  template<typename _CharT, typename _Traits>
703  {
704  _M_gcount = 0;
705  sentry __cerb(*this, true);
706  if (__cerb)
707  {
708  ios_base::iostate __err = ios_base::goodbit;
709  __try
710  {
711  _M_gcount = this->rdbuf()->sgetn(__s, __n);
712  if (_M_gcount != __n)
713  __err |= (ios_base::eofbit | ios_base::failbit);
714  }
716  {
717  this->_M_setstate(ios_base::badbit);
718  __throw_exception_again;
719  }
720  __catch(...)
721  { this->_M_setstate(ios_base::badbit); }
722  if (__err)
723  this->setstate(__err);
724  }
725  return *this;
726  }
727 
728  template<typename _CharT, typename _Traits>
729  streamsize
732  {
733  _M_gcount = 0;
734  sentry __cerb(*this, true);
735  if (__cerb)
736  {
737  ios_base::iostate __err = ios_base::goodbit;
738  __try
739  {
740  // Cannot compare int_type with streamsize generically.
741  const streamsize __num = this->rdbuf()->in_avail();
742  if (__num > 0)
743  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
744  else if (__num == -1)
745  __err |= ios_base::eofbit;
746  }
748  {
749  this->_M_setstate(ios_base::badbit);
750  __throw_exception_again;
751  }
752  __catch(...)
753  { this->_M_setstate(ios_base::badbit); }
754  if (__err)
755  this->setstate(__err);
756  }
757  return _M_gcount;
758  }
759 
760  template<typename _CharT, typename _Traits>
764  {
765  // _GLIBCXX_RESOLVE_LIB_DEFECTS
766  // 60. What is a formatted input function?
767  _M_gcount = 0;
768  // Clear eofbit per N3168.
769  this->clear(this->rdstate() & ~ios_base::eofbit);
770  sentry __cerb(*this, true);
771  if (__cerb)
772  {
773  ios_base::iostate __err = ios_base::goodbit;
774  __try
775  {
776  const int_type __eof = traits_type::eof();
777  __streambuf_type* __sb = this->rdbuf();
778  if (!__sb
779  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
780  __err |= ios_base::badbit;
781  }
783  {
784  this->_M_setstate(ios_base::badbit);
785  __throw_exception_again;
786  }
787  __catch(...)
788  { this->_M_setstate(ios_base::badbit); }
789  if (__err)
790  this->setstate(__err);
791  }
792  return *this;
793  }
794 
795  template<typename _CharT, typename _Traits>
798  unget(void)
799  {
800  // _GLIBCXX_RESOLVE_LIB_DEFECTS
801  // 60. What is a formatted input function?
802  _M_gcount = 0;
803  // Clear eofbit per N3168.
804  this->clear(this->rdstate() & ~ios_base::eofbit);
805  sentry __cerb(*this, true);
806  if (__cerb)
807  {
808  ios_base::iostate __err = ios_base::goodbit;
809  __try
810  {
811  const int_type __eof = traits_type::eof();
812  __streambuf_type* __sb = this->rdbuf();
813  if (!__sb
814  || traits_type::eq_int_type(__sb->sungetc(), __eof))
815  __err |= ios_base::badbit;
816  }
818  {
819  this->_M_setstate(ios_base::badbit);
820  __throw_exception_again;
821  }
822  __catch(...)
823  { this->_M_setstate(ios_base::badbit); }
824  if (__err)
825  this->setstate(__err);
826  }
827  return *this;
828  }
829 
830  template<typename _CharT, typename _Traits>
831  int
833  sync(void)
834  {
835  // _GLIBCXX_RESOLVE_LIB_DEFECTS
836  // DR60. Do not change _M_gcount.
837  int __ret = -1;
838  sentry __cerb(*this, true);
839  if (__cerb)
840  {
841  ios_base::iostate __err = ios_base::goodbit;
842  __try
843  {
844  __streambuf_type* __sb = this->rdbuf();
845  if (__sb)
846  {
847  if (__sb->pubsync() == -1)
848  __err |= ios_base::badbit;
849  else
850  __ret = 0;
851  }
852  }
854  {
855  this->_M_setstate(ios_base::badbit);
856  __throw_exception_again;
857  }
858  __catch(...)
859  { this->_M_setstate(ios_base::badbit); }
860  if (__err)
861  this->setstate(__err);
862  }
863  return __ret;
864  }
865 
866  template<typename _CharT, typename _Traits>
867  typename basic_istream<_CharT, _Traits>::pos_type
869  tellg(void)
870  {
871  // _GLIBCXX_RESOLVE_LIB_DEFECTS
872  // DR60. Do not change _M_gcount.
873  pos_type __ret = pos_type(-1);
874  sentry __cerb(*this, true);
875  if (__cerb)
876  {
877  __try
878  {
879  if (!this->fail())
880  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
881  ios_base::in);
882  }
884  {
885  this->_M_setstate(ios_base::badbit);
886  __throw_exception_again;
887  }
888  __catch(...)
889  { this->_M_setstate(ios_base::badbit); }
890  }
891  return __ret;
892  }
893 
894  template<typename _CharT, typename _Traits>
898  {
899  // _GLIBCXX_RESOLVE_LIB_DEFECTS
900  // DR60. Do not change _M_gcount.
901  // Clear eofbit per N3168.
902  this->clear(this->rdstate() & ~ios_base::eofbit);
903  sentry __cerb(*this, true);
904  if (__cerb)
905  {
906  ios_base::iostate __err = ios_base::goodbit;
907  __try
908  {
909  if (!this->fail())
910  {
911  // 136. seekp, seekg setting wrong streams?
912  const pos_type __p = this->rdbuf()->pubseekpos(__pos,
913  ios_base::in);
914 
915  // 129. Need error indication from seekp() and seekg()
916  if (__p == pos_type(off_type(-1)))
917  __err |= ios_base::failbit;
918  }
919  }
921  {
922  this->_M_setstate(ios_base::badbit);
923  __throw_exception_again;
924  }
925  __catch(...)
926  { this->_M_setstate(ios_base::badbit); }
927  if (__err)
928  this->setstate(__err);
929  }
930  return *this;
931  }
932 
933  template<typename _CharT, typename _Traits>
936  seekg(off_type __off, ios_base::seekdir __dir)
937  {
938  // _GLIBCXX_RESOLVE_LIB_DEFECTS
939  // DR60. Do not change _M_gcount.
940  // Clear eofbit per N3168.
941  this->clear(this->rdstate() & ~ios_base::eofbit);
942  sentry __cerb(*this, true);
943  if (__cerb)
944  {
945  ios_base::iostate __err = ios_base::goodbit;
946  __try
947  {
948  if (!this->fail())
949  {
950  // 136. seekp, seekg setting wrong streams?
951  const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
952  ios_base::in);
953 
954  // 129. Need error indication from seekp() and seekg()
955  if (__p == pos_type(off_type(-1)))
956  __err |= ios_base::failbit;
957  }
958  }
960  {
961  this->_M_setstate(ios_base::badbit);
962  __throw_exception_again;
963  }
964  __catch(...)
965  { this->_M_setstate(ios_base::badbit); }
966  if (__err)
967  this->setstate(__err);
968  }
969  return *this;
970  }
971 
972  // 27.6.1.2.3 Character extraction templates
973  template<typename _CharT, typename _Traits>
976  {
977  typedef basic_istream<_CharT, _Traits> __istream_type;
978  typedef typename __istream_type::int_type __int_type;
979 
980  typename __istream_type::sentry __cerb(__in, false);
981  if (__cerb)
982  {
983  ios_base::iostate __err = ios_base::goodbit;
984  __try
985  {
986  const __int_type __cb = __in.rdbuf()->sbumpc();
987  if (!_Traits::eq_int_type(__cb, _Traits::eof()))
988  __c = _Traits::to_char_type(__cb);
989  else
990  __err |= (ios_base::eofbit | ios_base::failbit);
991  }
993  {
994  __in._M_setstate(ios_base::badbit);
995  __throw_exception_again;
996  }
997  __catch(...)
998  { __in._M_setstate(ios_base::badbit); }
999  if (__err)
1000  __in.setstate(__err);
1001  }
1002  return __in;
1003  }
1004 
1005  template<typename _CharT, typename _Traits>
1006  void
1007  __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s,
1008  streamsize __num)
1009  {
1010  typedef basic_istream<_CharT, _Traits> __istream_type;
1011  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
1012  typedef typename _Traits::int_type int_type;
1013  typedef _CharT char_type;
1014  typedef ctype<_CharT> __ctype_type;
1015 
1016  streamsize __extracted = 0;
1018  typename __istream_type::sentry __cerb(__in, false);
1019  if (__cerb)
1020  {
1021  __try
1022  {
1023  // Figure out how many characters to extract.
1024  streamsize __width = __in.width();
1025  if (0 < __width && __width < __num)
1026  __num = __width;
1027 
1028  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1029 
1030  const int_type __eof = _Traits::eof();
1031  __streambuf_type* __sb = __in.rdbuf();
1032  int_type __c = __sb->sgetc();
1033 
1034  while (__extracted < __num - 1
1035  && !_Traits::eq_int_type(__c, __eof)
1036  && !__ct.is(ctype_base::space,
1037  _Traits::to_char_type(__c)))
1038  {
1039  *__s++ = _Traits::to_char_type(__c);
1040  ++__extracted;
1041  __c = __sb->snextc();
1042  }
1043 
1044  if (__extracted < __num - 1
1045  && _Traits::eq_int_type(__c, __eof))
1046  __err |= ios_base::eofbit;
1047 
1048  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1049  // 68. Extractors for char* should store null at end
1050  *__s = char_type();
1051  __in.width(0);
1052  }
1053  __catch(__cxxabiv1::__forced_unwind&)
1054  {
1055  __in._M_setstate(ios_base::badbit);
1056  __throw_exception_again;
1057  }
1058  __catch(...)
1059  { __in._M_setstate(ios_base::badbit); }
1060  }
1061  if (!__extracted)
1062  __err |= ios_base::failbit;
1063  if (__err)
1064  __in.setstate(__err);
1065  }
1066 
1067  // 27.6.1.4 Standard basic_istream manipulators
1068  template<typename _CharT, typename _Traits>
1069  basic_istream<_CharT, _Traits>&
1071  {
1072  typedef basic_istream<_CharT, _Traits> __istream_type;
1073  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
1074  typedef typename __istream_type::int_type __int_type;
1075  typedef ctype<_CharT> __ctype_type;
1076 
1077  // _GLIBCXX_RESOLVE_LIB_DEFECTS
1078  // 451. behavior of std::ws
1079  typename __istream_type::sentry __cerb(__in, true);
1080  if (__cerb)
1081  {
1082  ios_base::iostate __err = ios_base::goodbit;
1083  __try
1084  {
1085  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1086  const __int_type __eof = _Traits::eof();
1087  __streambuf_type* __sb = __in.rdbuf();
1088  __int_type __c = __sb->sgetc();
1089 
1090  while (true)
1091  {
1092  if (_Traits::eq_int_type(__c, __eof))
1093  {
1094  __err = ios_base::eofbit;
1095  break;
1096  }
1097  if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1098  break;
1099  __c = __sb->snextc();
1100  }
1101  }
1102  __catch (const __cxxabiv1::__forced_unwind&)
1103  {
1104  __in._M_setstate(ios_base::badbit);
1105  __throw_exception_again;
1106  }
1107  __catch (...)
1108  {
1109  __in._M_setstate(ios_base::badbit);
1110  }
1111  if (__err)
1112  __in.setstate(__err);
1113  }
1114  return __in;
1115  }
1116 
1117  // Inhibit implicit instantiations for required instantiations,
1118  // which are defined via explicit instantiations elsewhere.
1119 #if _GLIBCXX_EXTERN_TEMPLATE
1120  extern template class basic_istream<char>;
1121  extern template istream& ws(istream&);
1122  extern template istream& operator>>(istream&, char&);
1123  extern template istream& operator>>(istream&, unsigned char&);
1124  extern template istream& operator>>(istream&, signed char&);
1125 
1126  extern template istream& istream::_M_extract(unsigned short&);
1127  extern template istream& istream::_M_extract(unsigned int&);
1128  extern template istream& istream::_M_extract(long&);
1129  extern template istream& istream::_M_extract(unsigned long&);
1130  extern template istream& istream::_M_extract(bool&);
1131 #ifdef _GLIBCXX_USE_LONG_LONG
1132  extern template istream& istream::_M_extract(long long&);
1133  extern template istream& istream::_M_extract(unsigned long long&);
1134 #endif
1135  extern template istream& istream::_M_extract(float&);
1136  extern template istream& istream::_M_extract(double&);
1137  extern template istream& istream::_M_extract(long double&);
1138  extern template istream& istream::_M_extract(void*&);
1139 
1140  extern template class basic_iostream<char>;
1141 
1142 #ifdef _GLIBCXX_USE_WCHAR_T
1143  extern template class basic_istream<wchar_t>;
1144  extern template wistream& ws(wistream&);
1145  extern template wistream& operator>>(wistream&, wchar_t&);
1146  extern template void __istream_extract(wistream&, wchar_t*, streamsize);
1147 
1148  extern template wistream& wistream::_M_extract(unsigned short&);
1149  extern template wistream& wistream::_M_extract(unsigned int&);
1150  extern template wistream& wistream::_M_extract(long&);
1151  extern template wistream& wistream::_M_extract(unsigned long&);
1152  extern template wistream& wistream::_M_extract(bool&);
1153 #ifdef _GLIBCXX_USE_LONG_LONG
1154  extern template wistream& wistream::_M_extract(long long&);
1155  extern template wistream& wistream::_M_extract(unsigned long long&);
1156 #endif
1157  extern template wistream& wistream::_M_extract(float&);
1158  extern template wistream& wistream::_M_extract(double&);
1159  extern template wistream& wistream::_M_extract(long double&);
1160  extern template wistream& wistream::_M_extract(void*&);
1161 
1162  extern template class basic_iostream<wchar_t>;
1163 #endif
1164 #endif
1165 
1166 _GLIBCXX_END_NAMESPACE_VERSION
1167 } // namespace std
1168 
1169 #endif
ISO C++ entities toplevel namespace is std.
int_type get()
Simple extraction.
Definition: istream.tcc:261
pos_type tellg()
Getting the current read position.
Definition: istream.tcc:869
int sync()
Synchronizing the stream buffer.
Definition: istream.tcc:833
streamsize _M_gcount
Definition: istream:84
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
__istream_type & getline(char_type *__s, streamsize __n, char_type __delim)
String extraction.
Definition: istream.tcc:432
iter_type get(iter_type __in, iter_type __end, ios_base &__io, ios_base::iostate &__err, bool &__v) const
Numeric parsing.
__istream_type & operator>>(__istream_type &(*__pf)(__istream_type &))
Interface for manipulators.
Definition: istream:122
basic_istream< char > istream
Base class for char input streams.
Definition: iosfwd:140
int pubsync()
Calls virtual sync function.
Definition: streambuf:278
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:68
bool fail() const
Fast error checking.
Definition: basic_ios.h:205
bool is(mask __m, char_type __c) const
Test char_type classification.
int_type sbumpc()
Getting the next character.
Definition: streambuf:323
__istream_type & putback(char_type __c)
Unextracting a single character.
Definition: istream.tcc:763
_Traits::pos_type pos_type
Definition: basic_ios.h:82
static const openmode in
Open for input. Default for ifstream and fstream.
Definition: ios_base.h:487
basic_istream< _CharT, _Traits > & ws(basic_istream< _CharT, _Traits > &__is)
Quick and easy way to eat whitespace.
Definition: istream.tcc:1070
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
__istream_type & seekg(pos_type)
Changing the current read position.
Definition: istream.tcc:897
int_type snextc()
Getting the next character.
Definition: streambuf:305
__istream_type & unget()
Unextracting the previous character.
Definition: istream.tcc:798
Primary class template ctype facet.This template class defines classification and conversion function...
int_type peek()
Looking ahead in the stream.
Definition: istream.tcc:672
_Traits::off_type off_type
Definition: basic_ios.h:83
int_type sputc(char_type __c)
Entry point for all single-character output functions.
Definition: streambuf:431
The actual work of input and output (interface).
Definition: iosfwd:82
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.
Definition: basic_ios.h:325
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:233
void setstate(iostate __state)
Sets additional flags in the error state.
Definition: basic_ios.h:161
sentry(basic_istream< _CharT, _Traits > &__is, bool __noskipws=false)
The constructor performs all the work.
Definition: istream.tcc:47
static const fmtflags skipws
Skips leading white space before certain input operations.
Definition: ios_base.h:412
Primary class template num_get.This facet encapsulates the code to parse and return a number from a s...
Performs setup work for input streams.
Definition: istream:776
basic_istream< wchar_t > wistream
Base class for wchar_t input streams.
Definition: iosfwd:180
iostate rdstate() const
Returns the error state of the stream buffer.
Definition: basic_ios.h:141
int_type sputbackc(char_type __c)
Pushing characters back into the input stream.
Definition: streambuf:379
_Traits::int_type int_type
Definition: basic_ios.h:81
static const iostate eofbit
Indicates that an input operation reached the end of an input sequence.
Definition: ios_base.h:449
basic_ostream< _CharT, _Traits > * tie() const
Fetches the current tied stream.
Definition: basic_ios.h:299
void clear(iostate __state=goodbit)
[Re]sets the error state.
Definition: basic_ios.tcc:41
_Ios_Iostate iostate
This is a bitmask type.
Definition: ios_base.h:442
streamsize readsome(char_type *__s, streamsize __n)
Extraction until the buffer is exhausted, but no more.
Definition: istream.tcc:731
bool good() const
Fast error checking.
Definition: basic_ios.h:184
int_type sungetc()
Moving backwards in the input stream.
Definition: streambuf:404
__istream_type & ignore()
Simple extraction.
Definition: istream.tcc:492
static const iostate goodbit
Indicates all is well.
Definition: ios_base.h:457
Template class basic_istream.
Definition: iosfwd:85
int_type sgetc()
Getting the next character.
Definition: streambuf:345
locale getloc() const
Locale access.
Definition: ios_base.h:826
__istream_type & read(char_type *__s, streamsize __n)
Extraction without delimiters.
Definition: istream.tcc:702
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
Definition: cxxabi_forced.h:48
static const seekdir cur
Request a seek relative to the current position within the sequence.
Definition: ios_base.h:518
fmtflags flags() const
Access to format flags.
Definition: ios_base.h:682