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