libstdc++
istream.tcc
Go to the documentation of this file.
1// istream classes -*- C++ -*-
2
3// Copyright (C) 1997-2022 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
41namespace 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 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 }
414 __catch(__cxxabiv1::__forced_unwind&)
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>
430 basic_istream<_CharT, _Traits>&
431 basic_istream<_CharT, _Traits>::
432 getline(char_type* __s, streamsize __n, char_type __delim)
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 }
467 __catch(__cxxabiv1::__forced_unwind&)
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>
490 basic_istream<_CharT, _Traits>&
491 basic_istream<_CharT, _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 }
509 __catch(__cxxabiv1::__forced_unwind&)
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>
523 basic_istream<_CharT, _Traits>&
524 basic_istream<_CharT, _Traits>::
525 ignore(streamsize __n)
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 }
579 __catch(__cxxabiv1::__forced_unwind&)
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>
593 basic_istream<_CharT, _Traits>&
594 basic_istream<_CharT, _Traits>::
595 ignore(streamsize __n, int_type __delim)
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 }
656 __catch(__cxxabiv1::__forced_unwind&)
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
671 basic_istream<_CharT, _Traits>::
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 }
686 __catch(__cxxabiv1::__forced_unwind&)
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>
700 basic_istream<_CharT, _Traits>&
701 basic_istream<_CharT, _Traits>::
702 read(char_type* __s, streamsize __n)
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 }
715 __catch(__cxxabiv1::__forced_unwind&)
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
730 basic_istream<_CharT, _Traits>::
731 readsome(char_type* __s, streamsize __n)
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 }
747 __catch(__cxxabiv1::__forced_unwind&)
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>
761 basic_istream<_CharT, _Traits>&
762 basic_istream<_CharT, _Traits>::
763 putback(char_type __c)
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 }
782 __catch(__cxxabiv1::__forced_unwind&)
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>
796 basic_istream<_CharT, _Traits>&
797 basic_istream<_CharT, _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 }
817 __catch(__cxxabiv1::__forced_unwind&)
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
832 basic_istream<_CharT, _Traits>::
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 }
853 __catch(__cxxabiv1::__forced_unwind&)
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
868 basic_istream<_CharT, _Traits>::
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 }
883 __catch(__cxxabiv1::__forced_unwind&)
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>
895 basic_istream<_CharT, _Traits>&
896 basic_istream<_CharT, _Traits>::
897 seekg(pos_type __pos)
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 }
920 __catch(__cxxabiv1::__forced_unwind&)
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>
934 basic_istream<_CharT, _Traits>&
935 basic_istream<_CharT, _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 }
959 __catch(__cxxabiv1::__forced_unwind&)
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>
974 basic_istream<_CharT, _Traits>&
975 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
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 }
992 __catch(__cxxabiv1::__forced_unwind&)
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;
1017 ios_base::iostate __err = ios_base::goodbit;
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>&
1070 ws(basic_istream<_CharT, _Traits>& __in)
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
std::istream
basic_istream< char > istream
Base class for char input streams.
Definition: iosfwd:138
std::wistream
basic_istream< wchar_t > wistream
Base class for wchar_t input streams.
Definition: iosfwd:178
std::min
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:230
std
ISO C++ entities toplevel namespace is std.
std::streamsize
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:68
std::ws
basic_istream< _CharT, _Traits > & ws(basic_istream< _CharT, _Traits > &__is)
Quick and easy way to eat whitespace.
Definition: istream.tcc:1070
std::basic_ios::clear
void clear(iostate __state=goodbit)
[Re]sets the error state.
Definition: basic_ios.tcc:41
std::basic_ios::tie
basic_ostream< _CharT, _Traits > * tie() const
Fetches the current tied stream.
Definition: basic_ios.h:295
std::basic_ios::setstate
void setstate(iostate __state)
Sets additional flags in the error state.
Definition: basic_ios.h:157
std::basic_ios::rdstate
iostate rdstate() const
Returns the error state of the stream buffer.
Definition: basic_ios.h:137
std::basic_ios::good
bool good() const
Fast error checking.
Definition: basic_ios.h:180
std::basic_ios::fail
bool fail() const
Fast error checking.
Definition: basic_ios.h:201
std::basic_ios::rdbuf
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.
Definition: basic_ios.h:321
std::basic_streambuf
The actual work of input and output (interface).
Definition: streambuf:123
std::basic_streambuf::snextc
int_type snextc()
Getting the next character.
Definition: streambuf:303
std::basic_streambuf::sbumpc
int_type sbumpc()
Getting the next character.
Definition: streambuf:321
std::basic_streambuf::sungetc
int_type sungetc()
Moving backwards in the input stream.
Definition: streambuf:402
std::basic_streambuf::sgetc
int_type sgetc()
Getting the next character.
Definition: streambuf:343
std::basic_streambuf::pubsync
int pubsync()
Calls virtual sync function.
Definition: streambuf:276
std::basic_streambuf::sputbackc
int_type sputbackc(char_type __c)
Pushing characters back into the input stream.
Definition: streambuf:377
std::basic_streambuf::sputc
int_type sputc(char_type __c)
Entry point for all single-character output functions.
Definition: streambuf:429
std::basic_istream
Template class basic_istream.
Definition: istream:59
std::basic_istream::seekg
__istream_type & seekg(pos_type)
Changing the current read position.
Definition: istream.tcc:897
std::basic_istream::get
int_type get()
Simple extraction.
Definition: istream.tcc:261
std::basic_istream::readsome
streamsize readsome(char_type *__s, streamsize __n)
Extraction until the buffer is exhausted, but no more.
Definition: istream.tcc:731
std::basic_istream::peek
int_type peek()
Looking ahead in the stream.
Definition: istream.tcc:672
std::basic_istream::unget
__istream_type & unget()
Unextracting the previous character.
Definition: istream.tcc:798
std::basic_istream::tellg
pos_type tellg()
Getting the current read position.
Definition: istream.tcc:869
std::basic_istream::_M_gcount
streamsize _M_gcount
Definition: istream:82
std::basic_istream::ignore
__istream_type & ignore()
Simple extraction.
Definition: istream.tcc:492
std::basic_istream::read
__istream_type & read(char_type *__s, streamsize __n)
Extraction without delimiters.
Definition: istream.tcc:702
std::basic_istream::putback
__istream_type & putback(char_type __c)
Unextracting a single character.
Definition: istream.tcc:763
std::basic_istream::getline
__istream_type & getline(char_type *__s, streamsize __n, char_type __delim)
String extraction.
Definition: istream.tcc:432
std::basic_istream::operator>>
__istream_type & operator>>(__istream_type &(*__pf)(__istream_type &))
Interface for manipulators.
Definition: istream:120
std::basic_istream::sync
int sync()
Synchronizing the stream buffer.
Definition: istream.tcc:833
std::basic_istream::sentry
Performs setup work for input streams.
Definition: istream:687
std::basic_istream::sentry::sentry
sentry(basic_istream< _CharT, _Traits > &__is, bool __noskipws=false)
The constructor performs all the work.
Definition: istream.tcc:47
__cxxabiv1::__forced_unwind
Thrown as part of forced unwinding.
Definition: cxxabi_forced.h:49
std::ios_base::skipws
static const fmtflags skipws
Skips leading white space before certain input operations.
Definition: ios_base.h:391
std::ios_base::iostate
_Ios_Iostate iostate
This is a bitmask type.
Definition: ios_base.h:421
std::ios_base::cur
static const seekdir cur
Request a seek relative to the current position within the sequence.
Definition: ios_base.h:498
std::ios_base::in
static const openmode in
Open for input. Default for ifstream and fstream.
Definition: ios_base.h:466
std::ios_base::flags
fmtflags flags() const
Access to format flags.
Definition: ios_base.h:662
std::ios_base::eofbit
static const iostate eofbit
Indicates that an input operation reached the end of an input sequence.
Definition: ios_base.h:428
std::ios_base::goodbit
static const iostate goodbit
Indicates all is well.
Definition: ios_base.h:436
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:425
std::ios_base::getloc
locale getloc() const
Locale access.
Definition: ios_base.h:806
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:433
std::__ctype_abstract_base::is
bool is(mask __m, char_type __c) const
Test char_type classification.
Definition: locale_facets.h:172
std::ctype
Primary class template ctype facet.
Definition: locale_facets.h:616
std::num_get
Primary class template num_get.
Definition: locale_facets.h:1961
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