libstdc++

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