source: Daodan/MSYS2/mingw32/include/c++/11.2.0/bits/istream.tcc

Last change on this file was 1166, checked in by rossy, 3 years ago

Daodan: Replace MinGW build env with an up-to-date MSYS2 env
File size: 30.9 KB
RevLine 
[1166]1// istream classes -*- C++ -*-
2
3// Copyright (C) 1997-2021 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 unsigned long long __gcount = 0;
379
380 while (!traits_type::eq_int_type(__c, __eof)
381 && !traits_type::eq_int_type(__c, __idelim)
382 && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
383 {
384 ++__gcount;
385 __c = __this_sb->snextc();
386 __c2 = traits_type::to_char_type(__c);
387 }
388 if (traits_type::eq_int_type(__c, __eof))
389 __err |= ios_base::eofbit;
390 // _GLIBCXX_RESOLVE_LIB_DEFECTS
391 // 3464. istream::gcount() can overflow
392 if (__gcount <= __gnu_cxx::__numeric_traits<streamsize>::__max)
393 _M_gcount = __gcount;
394 else
395 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
396 }
397 __catch(__cxxabiv1::__forced_unwind&)
398 {
399 this->_M_setstate(ios_base::badbit);
400 __throw_exception_again;
401 }
402 __catch(...)
403 { this->_M_setstate(ios_base::badbit); }
404 }
405 if (!_M_gcount)
406 __err |= ios_base::failbit;
407 if (__err)
408 this->setstate(__err);
409 return *this;
410 }
411
412 template<typename _CharT, typename _Traits>
413 basic_istream<_CharT, _Traits>&
414 basic_istream<_CharT, _Traits>::
415 getline(char_type* __s, streamsize __n, char_type __delim)
416 {
417 _M_gcount = 0;
418 ios_base::iostate __err = ios_base::goodbit;
419 sentry __cerb(*this, true);
420 if (__cerb)
421 {
422 __try
423 {
424 const int_type __idelim = traits_type::to_int_type(__delim);
425 const int_type __eof = traits_type::eof();
426 __streambuf_type* __sb = this->rdbuf();
427 int_type __c = __sb->sgetc();
428
429 while (_M_gcount + 1 < __n
430 && !traits_type::eq_int_type(__c, __eof)
431 && !traits_type::eq_int_type(__c, __idelim))
432 {
433 *__s++ = traits_type::to_char_type(__c);
434 __c = __sb->snextc();
435 ++_M_gcount;
436 }
437 if (traits_type::eq_int_type(__c, __eof))
438 __err |= ios_base::eofbit;
439 else
440 {
441 if (traits_type::eq_int_type(__c, __idelim))
442 {
443 __sb->sbumpc();
444 ++_M_gcount;
445 }
446 else
447 __err |= ios_base::failbit;
448 }
449 }
450 __catch(__cxxabiv1::__forced_unwind&)
451 {
452 this->_M_setstate(ios_base::badbit);
453 __throw_exception_again;
454 }
455 __catch(...)
456 { this->_M_setstate(ios_base::badbit); }
457 }
458 // _GLIBCXX_RESOLVE_LIB_DEFECTS
459 // 243. get and getline when sentry reports failure.
460 if (__n > 0)
461 *__s = char_type();
462 if (!_M_gcount)
463 __err |= ios_base::failbit;
464 if (__err)
465 this->setstate(__err);
466 return *this;
467 }
468
469 // We provide three overloads, since the first two are much simpler
470 // than the general case. Also, the latter two can thus adopt the
471 // same "batchy" strategy used by getline above.
472 template<typename _CharT, typename _Traits>
473 basic_istream<_CharT, _Traits>&
474 basic_istream<_CharT, _Traits>::
475 ignore(void)
476 {
477 _M_gcount = 0;
478 sentry __cerb(*this, true);
479 if (__cerb)
480 {
481 ios_base::iostate __err = ios_base::goodbit;
482 __try
483 {
484 const int_type __eof = traits_type::eof();
485 __streambuf_type* __sb = this->rdbuf();
486
487 if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
488 __err |= ios_base::eofbit;
489 else
490 _M_gcount = 1;
491 }
492 __catch(__cxxabiv1::__forced_unwind&)
493 {
494 this->_M_setstate(ios_base::badbit);
495 __throw_exception_again;
496 }
497 __catch(...)
498 { this->_M_setstate(ios_base::badbit); }
499 if (__err)
500 this->setstate(__err);
501 }
502 return *this;
503 }
504
505 template<typename _CharT, typename _Traits>
506 basic_istream<_CharT, _Traits>&
507 basic_istream<_CharT, _Traits>::
508 ignore(streamsize __n)
509 {
510 _M_gcount = 0;
511 sentry __cerb(*this, true);
512 if (__cerb && __n > 0)
513 {
514 ios_base::iostate __err = ios_base::goodbit;
515 __try
516 {
517 const int_type __eof = traits_type::eof();
518 __streambuf_type* __sb = this->rdbuf();
519 int_type __c = __sb->sgetc();
520
521 // N.B. On LFS-enabled platforms streamsize is still 32 bits
522 // wide: if we want to implement the standard mandated behavior
523 // for n == max() (see 27.6.1.3/24) we are at risk of signed
524 // integer overflow: thus these contortions. Also note that,
525 // by definition, when more than 2G chars are actually ignored,
526 // _M_gcount (the return value of gcount, that is) cannot be
527 // really correct, being unavoidably too small.
528 bool __large_ignore = false;
529 while (true)
530 {
531 while (_M_gcount < __n
532 && !traits_type::eq_int_type(__c, __eof))
533 {
534 ++_M_gcount;
535 __c = __sb->snextc();
536 }
537 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
538 && !traits_type::eq_int_type(__c, __eof))
539 {
540 _M_gcount =
541 __gnu_cxx::__numeric_traits<streamsize>::__min;
542 __large_ignore = true;
543 }
544 else
545 break;
546 }
547
548 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
549 {
550 if (__large_ignore)
551 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
552
553 if (traits_type::eq_int_type(__c, __eof))
554 __err |= ios_base::eofbit;
555 }
556 else if (_M_gcount < __n)
557 {
558 if (traits_type::eq_int_type(__c, __eof))
559 __err |= ios_base::eofbit;
560 }
561 }
562 __catch(__cxxabiv1::__forced_unwind&)
563 {
564 this->_M_setstate(ios_base::badbit);
565 __throw_exception_again;
566 }
567 __catch(...)
568 { this->_M_setstate(ios_base::badbit); }
569 if (__err)
570 this->setstate(__err);
571 }
572 return *this;
573 }
574
575 template<typename _CharT, typename _Traits>
576 basic_istream<_CharT, _Traits>&
577 basic_istream<_CharT, _Traits>::
578 ignore(streamsize __n, int_type __delim)
579 {
580 _M_gcount = 0;
581 sentry __cerb(*this, true);
582 if (__cerb && __n > 0)
583 {
584 ios_base::iostate __err = ios_base::goodbit;
585 __try
586 {
587 const int_type __eof = traits_type::eof();
588 __streambuf_type* __sb = this->rdbuf();
589 int_type __c = __sb->sgetc();
590
591 // See comment above.
592 bool __large_ignore = false;
593 while (true)
594 {
595 while (_M_gcount < __n
596 && !traits_type::eq_int_type(__c, __eof)
597 && !traits_type::eq_int_type(__c, __delim))
598 {
599 ++_M_gcount;
600 __c = __sb->snextc();
601 }
602 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
603 && !traits_type::eq_int_type(__c, __eof)
604 && !traits_type::eq_int_type(__c, __delim))
605 {
606 _M_gcount =
607 __gnu_cxx::__numeric_traits<streamsize>::__min;
608 __large_ignore = true;
609 }
610 else
611 break;
612 }
613
614 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
615 {
616 if (__large_ignore)
617 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
618
619 if (traits_type::eq_int_type(__c, __eof))
620 __err |= ios_base::eofbit;
621 else
622 {
623 if (_M_gcount != __n)
624 ++_M_gcount;
625 __sb->sbumpc();
626 }
627 }
628 else if (_M_gcount < __n) // implies __c == __delim or EOF
629 {
630 if (traits_type::eq_int_type(__c, __eof))
631 __err |= ios_base::eofbit;
632 else
633 {
634 ++_M_gcount;
635 __sb->sbumpc();
636 }
637 }
638 }
639 __catch(__cxxabiv1::__forced_unwind&)
640 {
641 this->_M_setstate(ios_base::badbit);
642 __throw_exception_again;
643 }
644 __catch(...)
645 { this->_M_setstate(ios_base::badbit); }
646 if (__err)
647 this->setstate(__err);
648 }
649 return *this;
650 }
651
652 template<typename _CharT, typename _Traits>
653 typename basic_istream<_CharT, _Traits>::int_type
654 basic_istream<_CharT, _Traits>::
655 peek(void)
656 {
657 int_type __c = traits_type::eof();
658 _M_gcount = 0;
659 sentry __cerb(*this, true);
660 if (__cerb)
661 {
662 ios_base::iostate __err = ios_base::goodbit;
663 __try
664 {
665 __c = this->rdbuf()->sgetc();
666 if (traits_type::eq_int_type(__c, traits_type::eof()))
667 __err |= ios_base::eofbit;
668 }
669 __catch(__cxxabiv1::__forced_unwind&)
670 {
671 this->_M_setstate(ios_base::badbit);
672 __throw_exception_again;
673 }
674 __catch(...)
675 { this->_M_setstate(ios_base::badbit); }
676 if (__err)
677 this->setstate(__err);
678 }
679 return __c;
680 }
681
682 template<typename _CharT, typename _Traits>
683 basic_istream<_CharT, _Traits>&
684 basic_istream<_CharT, _Traits>::
685 read(char_type* __s, streamsize __n)
686 {
687 _M_gcount = 0;
688 sentry __cerb(*this, true);
689 if (__cerb)
690 {
691 ios_base::iostate __err = ios_base::goodbit;
692 __try
693 {
694 _M_gcount = this->rdbuf()->sgetn(__s, __n);
695 if (_M_gcount != __n)
696 __err |= (ios_base::eofbit | ios_base::failbit);
697 }
698 __catch(__cxxabiv1::__forced_unwind&)
699 {
700 this->_M_setstate(ios_base::badbit);
701 __throw_exception_again;
702 }
703 __catch(...)
704 { this->_M_setstate(ios_base::badbit); }
705 if (__err)
706 this->setstate(__err);
707 }
708 return *this;
709 }
710
711 template<typename _CharT, typename _Traits>
712 streamsize
713 basic_istream<_CharT, _Traits>::
714 readsome(char_type* __s, streamsize __n)
715 {
716 _M_gcount = 0;
717 sentry __cerb(*this, true);
718 if (__cerb)
719 {
720 ios_base::iostate __err = ios_base::goodbit;
721 __try
722 {
723 // Cannot compare int_type with streamsize generically.
724 const streamsize __num = this->rdbuf()->in_avail();
725 if (__num > 0)
726 _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
727 else if (__num == -1)
728 __err |= ios_base::eofbit;
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 _M_gcount;
741 }
742
743 template<typename _CharT, typename _Traits>
744 basic_istream<_CharT, _Traits>&
745 basic_istream<_CharT, _Traits>::
746 putback(char_type __c)
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->sputbackc(__c), __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 basic_istream<_CharT, _Traits>&
780 basic_istream<_CharT, _Traits>::
781 unget(void)
782 {
783 // _GLIBCXX_RESOLVE_LIB_DEFECTS
784 // 60. What is a formatted input function?
785 _M_gcount = 0;
786 // Clear eofbit per N3168.
787 this->clear(this->rdstate() & ~ios_base::eofbit);
788 sentry __cerb(*this, true);
789 if (__cerb)
790 {
791 ios_base::iostate __err = ios_base::goodbit;
792 __try
793 {
794 const int_type __eof = traits_type::eof();
795 __streambuf_type* __sb = this->rdbuf();
796 if (!__sb
797 || traits_type::eq_int_type(__sb->sungetc(), __eof))
798 __err |= ios_base::badbit;
799 }
800 __catch(__cxxabiv1::__forced_unwind&)
801 {
802 this->_M_setstate(ios_base::badbit);
803 __throw_exception_again;
804 }
805 __catch(...)
806 { this->_M_setstate(ios_base::badbit); }
807 if (__err)
808 this->setstate(__err);
809 }
810 return *this;
811 }
812
813 template<typename _CharT, typename _Traits>
814 int
815 basic_istream<_CharT, _Traits>::
816 sync(void)
817 {
818 // _GLIBCXX_RESOLVE_LIB_DEFECTS
819 // DR60. Do not change _M_gcount.
820 int __ret = -1;
821 sentry __cerb(*this, true);
822 if (__cerb)
823 {
824 ios_base::iostate __err = ios_base::goodbit;
825 __try
826 {
827 __streambuf_type* __sb = this->rdbuf();
828 if (__sb)
829 {
830 if (__sb->pubsync() == -1)
831 __err |= ios_base::badbit;
832 else
833 __ret = 0;
834 }
835 }
836 __catch(__cxxabiv1::__forced_unwind&)
837 {
838 this->_M_setstate(ios_base::badbit);
839 __throw_exception_again;
840 }
841 __catch(...)
842 { this->_M_setstate(ios_base::badbit); }
843 if (__err)
844 this->setstate(__err);
845 }
846 return __ret;
847 }
848
849 template<typename _CharT, typename _Traits>
850 typename basic_istream<_CharT, _Traits>::pos_type
851 basic_istream<_CharT, _Traits>::
852 tellg(void)
853 {
854 // _GLIBCXX_RESOLVE_LIB_DEFECTS
855 // DR60. Do not change _M_gcount.
856 pos_type __ret = pos_type(-1);
857 sentry __cerb(*this, true);
858 if (__cerb)
859 {
860 __try
861 {
862 if (!this->fail())
863 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
864 ios_base::in);
865 }
866 __catch(__cxxabiv1::__forced_unwind&)
867 {
868 this->_M_setstate(ios_base::badbit);
869 __throw_exception_again;
870 }
871 __catch(...)
872 { this->_M_setstate(ios_base::badbit); }
873 }
874 return __ret;
875 }
876
877 template<typename _CharT, typename _Traits>
878 basic_istream<_CharT, _Traits>&
879 basic_istream<_CharT, _Traits>::
880 seekg(pos_type __pos)
881 {
882 // _GLIBCXX_RESOLVE_LIB_DEFECTS
883 // DR60. Do not change _M_gcount.
884 // Clear eofbit per N3168.
885 this->clear(this->rdstate() & ~ios_base::eofbit);
886 sentry __cerb(*this, true);
887 if (__cerb)
888 {
889 ios_base::iostate __err = ios_base::goodbit;
890 __try
891 {
892 if (!this->fail())
893 {
894 // 136. seekp, seekg setting wrong streams?
895 const pos_type __p = this->rdbuf()->pubseekpos(__pos,
896 ios_base::in);
897
898 // 129. Need error indication from seekp() and seekg()
899 if (__p == pos_type(off_type(-1)))
900 __err |= ios_base::failbit;
901 }
902 }
903 __catch(__cxxabiv1::__forced_unwind&)
904 {
905 this->_M_setstate(ios_base::badbit);
906 __throw_exception_again;
907 }
908 __catch(...)
909 { this->_M_setstate(ios_base::badbit); }
910 if (__err)
911 this->setstate(__err);
912 }
913 return *this;
914 }
915
916 template<typename _CharT, typename _Traits>
917 basic_istream<_CharT, _Traits>&
918 basic_istream<_CharT, _Traits>::
919 seekg(off_type __off, ios_base::seekdir __dir)
920 {
921 // _GLIBCXX_RESOLVE_LIB_DEFECTS
922 // DR60. Do not change _M_gcount.
923 // Clear eofbit per N3168.
924 this->clear(this->rdstate() & ~ios_base::eofbit);
925 sentry __cerb(*this, true);
926 if (__cerb)
927 {
928 ios_base::iostate __err = ios_base::goodbit;
929 __try
930 {
931 if (!this->fail())
932 {
933 // 136. seekp, seekg setting wrong streams?
934 const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
935 ios_base::in);
936
937 // 129. Need error indication from seekp() and seekg()
938 if (__p == pos_type(off_type(-1)))
939 __err |= ios_base::failbit;
940 }
941 }
942 __catch(__cxxabiv1::__forced_unwind&)
943 {
944 this->_M_setstate(ios_base::badbit);
945 __throw_exception_again;
946 }
947 __catch(...)
948 { this->_M_setstate(ios_base::badbit); }
949 if (__err)
950 this->setstate(__err);
951 }
952 return *this;
953 }
954
955 // 27.6.1.2.3 Character extraction templates
956 template<typename _CharT, typename _Traits>
957 basic_istream<_CharT, _Traits>&
958 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
959 {
960 typedef basic_istream<_CharT, _Traits> __istream_type;
961 typedef typename __istream_type::int_type __int_type;
962
963 typename __istream_type::sentry __cerb(__in, false);
964 if (__cerb)
965 {
966 ios_base::iostate __err = ios_base::goodbit;
967 __try
968 {
969 const __int_type __cb = __in.rdbuf()->sbumpc();
970 if (!_Traits::eq_int_type(__cb, _Traits::eof()))
971 __c = _Traits::to_char_type(__cb);
972 else
973 __err |= (ios_base::eofbit | ios_base::failbit);
974 }
975 __catch(__cxxabiv1::__forced_unwind&)
976 {
977 __in._M_setstate(ios_base::badbit);
978 __throw_exception_again;
979 }
980 __catch(...)
981 { __in._M_setstate(ios_base::badbit); }
982 if (__err)
983 __in.setstate(__err);
984 }
985 return __in;
986 }
987
988 template<typename _CharT, typename _Traits>
989 void
990 __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s,
991 streamsize __num)
992 {
993 typedef basic_istream<_CharT, _Traits> __istream_type;
994 typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
995 typedef typename _Traits::int_type int_type;
996 typedef _CharT char_type;
997 typedef ctype<_CharT> __ctype_type;
998
999 streamsize __extracted = 0;
1000 ios_base::iostate __err = ios_base::goodbit;
1001 typename __istream_type::sentry __cerb(__in, false);
1002 if (__cerb)
1003 {
1004 __try
1005 {
1006 // Figure out how many characters to extract.
1007 streamsize __width = __in.width();
1008 if (0 < __width && __width < __num)
1009 __num = __width;
1010
1011 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1012
1013 const int_type __eof = _Traits::eof();
1014 __streambuf_type* __sb = __in.rdbuf();
1015 int_type __c = __sb->sgetc();
1016
1017 while (__extracted < __num - 1
1018 && !_Traits::eq_int_type(__c, __eof)
1019 && !__ct.is(ctype_base::space,
1020 _Traits::to_char_type(__c)))
1021 {
1022 *__s++ = _Traits::to_char_type(__c);
1023 ++__extracted;
1024 __c = __sb->snextc();
1025 }
1026
1027 if (__extracted < __num - 1
1028 && _Traits::eq_int_type(__c, __eof))
1029 __err |= ios_base::eofbit;
1030
1031 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1032 // 68. Extractors for char* should store null at end
1033 *__s = char_type();
1034 __in.width(0);
1035 }
1036 __catch(__cxxabiv1::__forced_unwind&)
1037 {
1038 __in._M_setstate(ios_base::badbit);
1039 __throw_exception_again;
1040 }
1041 __catch(...)
1042 { __in._M_setstate(ios_base::badbit); }
1043 }
1044 if (!__extracted)
1045 __err |= ios_base::failbit;
1046 if (__err)
1047 __in.setstate(__err);
1048 }
1049
1050 // 27.6.1.4 Standard basic_istream manipulators
1051 template<typename _CharT, typename _Traits>
1052 basic_istream<_CharT, _Traits>&
1053 ws(basic_istream<_CharT, _Traits>& __in)
1054 {
1055 typedef basic_istream<_CharT, _Traits> __istream_type;
1056 typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
1057 typedef typename __istream_type::int_type __int_type;
1058 typedef ctype<_CharT> __ctype_type;
1059
1060 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1061 const __int_type __eof = _Traits::eof();
1062 __streambuf_type* __sb = __in.rdbuf();
1063 __int_type __c = __sb->sgetc();
1064
1065 while (!_Traits::eq_int_type(__c, __eof)
1066 && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1067 __c = __sb->snextc();
1068
1069 if (_Traits::eq_int_type(__c, __eof))
1070 __in.setstate(ios_base::eofbit);
1071 return __in;
1072 }
1073
1074 // Inhibit implicit instantiations for required instantiations,
1075 // which are defined via explicit instantiations elsewhere.
1076#if _GLIBCXX_EXTERN_TEMPLATE
1077 extern template class basic_istream<char>;
1078 extern template istream& ws(istream&);
1079 extern template istream& operator>>(istream&, char&);
1080 extern template istream& operator>>(istream&, unsigned char&);
1081 extern template istream& operator>>(istream&, signed char&);
1082
1083 extern template istream& istream::_M_extract(unsigned short&);
1084 extern template istream& istream::_M_extract(unsigned int&);
1085 extern template istream& istream::_M_extract(long&);
1086 extern template istream& istream::_M_extract(unsigned long&);
1087 extern template istream& istream::_M_extract(bool&);
1088#ifdef _GLIBCXX_USE_LONG_LONG
1089 extern template istream& istream::_M_extract(long long&);
1090 extern template istream& istream::_M_extract(unsigned long long&);
1091#endif
1092 extern template istream& istream::_M_extract(float&);
1093 extern template istream& istream::_M_extract(double&);
1094 extern template istream& istream::_M_extract(long double&);
1095 extern template istream& istream::_M_extract(void*&);
1096
1097 extern template class basic_iostream<char>;
1098
1099#ifdef _GLIBCXX_USE_WCHAR_T
1100 extern template class basic_istream<wchar_t>;
1101 extern template wistream& ws(wistream&);
1102 extern template wistream& operator>>(wistream&, wchar_t&);
1103 extern template void __istream_extract(wistream&, wchar_t*, streamsize);
1104
1105 extern template wistream& wistream::_M_extract(unsigned short&);
1106 extern template wistream& wistream::_M_extract(unsigned int&);
1107 extern template wistream& wistream::_M_extract(long&);
1108 extern template wistream& wistream::_M_extract(unsigned long&);
1109 extern template wistream& wistream::_M_extract(bool&);
1110#ifdef _GLIBCXX_USE_LONG_LONG
1111 extern template wistream& wistream::_M_extract(long long&);
1112 extern template wistream& wistream::_M_extract(unsigned long long&);
1113#endif
1114 extern template wistream& wistream::_M_extract(float&);
1115 extern template wistream& wistream::_M_extract(double&);
1116 extern template wistream& wistream::_M_extract(long double&);
1117 extern template wistream& wistream::_M_extract(void*&);
1118
1119 extern template class basic_iostream<wchar_t>;
1120#endif
1121#endif
1122
1123_GLIBCXX_END_NAMESPACE_VERSION
1124} // namespace std
1125
1126#endif
Note: See TracBrowser for help on using the repository browser.