| blob | 2658866ec5784c94d993b4d9b2182314d1980b0e |
1 // istream classes -*- C++ -*-
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
4 // Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING. If not, write to the Free
19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 // USA.
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction. Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License. This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
31 //
32 // ISO C++ 14882: 27.6.2 Output streams
33 //
35 #pragma GCC system_header
37 #include <locale>
38 #include <ostream> // For flush()
40 namespace std
41 {
42 template<typename _CharT, typename _Traits>
43 basic_istream<_CharT, _Traits>::sentry::
44 sentry(basic_istream<_CharT, _Traits>& __in, bool __noskipws)
45 {
46 if (__in.good())
47 {
48 if (__in.tie())
49 __in.tie()->flush();
50 if (!__noskipws && (__in.flags() & ios_base::skipws))
51 {
52 const __int_type __eof = traits_type::eof();
53 __streambuf_type* __sb = __in.rdbuf();
54 __int_type __c = __sb->sgetc();
56 if (__in._M_check_facet(__in._M_fctype))
57 while (__c != __eof
58 && __in._M_fctype->is(ctype_base::space, __c))
59 __c = __sb->snextc();
61 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
62 //195. Should basic_istream::sentry's constructor ever set eofbit?
63 if (__c == __eof)
64 __in.setstate(ios_base::eofbit);
65 #endif
66 }
67 }
69 if (__in.good())
70 _M_ok = true;
71 else
72 {
73 _M_ok = false;
74 __in.setstate(ios_base::failbit);
75 }
76 }
78 template<typename _CharT, typename _Traits>
79 basic_istream<_CharT, _Traits>&
80 basic_istream<_CharT, _Traits>::
81 operator>>(__istream_type& (*__pf)(__istream_type&))
82 {
83 __pf(*this);
84 return *this;
85 }
87 template<typename _CharT, typename _Traits>
88 basic_istream<_CharT, _Traits>&
89 basic_istream<_CharT, _Traits>::
90 operator>>(__ios_type& (*__pf)(__ios_type&))
91 {
92 __pf(*this);
93 return *this;
94 }
96 template<typename _CharT, typename _Traits>
97 basic_istream<_CharT, _Traits>&
98 basic_istream<_CharT, _Traits>::
99 operator>>(ios_base& (*__pf)(ios_base&))
100 {
101 __pf(*this);
102 return *this;
103 }
105 template<typename _CharT, typename _Traits>
106 basic_istream<_CharT, _Traits>&
107 basic_istream<_CharT, _Traits>::
108 operator>>(bool& __n)
109 {
110 sentry __cerb(*this, false);
111 if (__cerb)
112 {
113 try
114 {
115 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
116 if (_M_check_facet(_M_fnumget))
117 _M_fnumget->get(*this, 0, *this, __err, __n);
118 this->setstate(__err);
119 }
120 catch(exception& __fail)
121 {
122 // 27.6.1.2.1 Common requirements.
123 // Turn this on without causing an ios::failure to be thrown.
124 this->setstate(ios_base::badbit);
125 if ((this->exceptions() & ios_base::badbit) != 0)
126 __throw_exception_again;
127 }
128 }
129 return *this;
130 }
132 template<typename _CharT, typename _Traits>
133 basic_istream<_CharT, _Traits>&
134 basic_istream<_CharT, _Traits>::
135 operator>>(short& __n)
136 {
137 sentry __cerb(*this, false);
138 if (__cerb)
139 {
140 try
141 {
142 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
143 long __l;
144 if (_M_check_facet(_M_fnumget))
145 _M_fnumget->get(*this, 0, *this, __err, __l);
146 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
147 // 118. basic_istream uses nonexistent num_get member functions.
148 if (!(__err & ios_base::failbit)
149 && (numeric_limits<short>::min() <= __l
150 && __l <= numeric_limits<short>::max()))
151 __n = __l;
152 else
153 __err |= ios_base::failbit;
154 #endif
155 this->setstate(__err);
156 }
157 catch(exception& __fail)
158 {
159 // 27.6.1.2.1 Common requirements.
160 // Turn this on without causing an ios::failure to be thrown.
161 this->setstate(ios_base::badbit);
162 if ((this->exceptions() & ios_base::badbit) != 0)
163 __throw_exception_again;
164 }
165 }
166 return *this;
167 }
169 template<typename _CharT, typename _Traits>
170 basic_istream<_CharT, _Traits>&
171 basic_istream<_CharT, _Traits>::
172 operator>>(unsigned short& __n)
173 {
174 sentry __cerb(*this, false);
175 if (__cerb)
176 {
177 try
178 {
179 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
180 if (_M_check_facet(_M_fnumget))
181 _M_fnumget->get(*this, 0, *this, __err, __n);
182 this->setstate(__err);
183 }
184 catch(exception& __fail)
185 {
186 // 27.6.1.2.1 Common requirements.
187 // Turn this on without causing an ios::failure to be thrown.
188 this->setstate(ios_base::badbit);
189 if ((this->exceptions() & ios_base::badbit) != 0)
190 __throw_exception_again;
191 }
192 }
193 return *this;
194 }
196 template<typename _CharT, typename _Traits>
197 basic_istream<_CharT, _Traits>&
198 basic_istream<_CharT, _Traits>::
199 operator>>(int& __n)
200 {
201 sentry __cerb(*this, false);
202 if (__cerb)
203 {
204 try
205 {
206 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
207 long __l;
208 if (_M_check_facet(_M_fnumget))
209 _M_fnumget->get(*this, 0, *this, __err, __l);
210 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
211 // 118. basic_istream uses nonexistent num_get member functions.
212 if (!(__err & ios_base::failbit)
213 && (numeric_limits<int>::min() <= __l
214 && __l <= numeric_limits<int>::max()))
215 __n = __l;
216 else
217 __err |= ios_base::failbit;
218 #endif
219 this->setstate(__err);
220 }
221 catch(exception& __fail)
222 {
223 // 27.6.1.2.1 Common requirements.
224 // Turn this on without causing an ios::failure to be thrown.
225 this->setstate(ios_base::badbit);
226 if ((this->exceptions() & ios_base::badbit) != 0)
227 __throw_exception_again;
228 }
229 }
230 return *this;
231 }
233 template<typename _CharT, typename _Traits>
234 basic_istream<_CharT, _Traits>&
235 basic_istream<_CharT, _Traits>::
236 operator>>(unsigned int& __n)
237 {
238 sentry __cerb(*this, false);
239 if (__cerb)
240 {
241 try
242 {
243 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
244 if (_M_check_facet(_M_fnumget))
245 _M_fnumget->get(*this, 0, *this, __err, __n);
246 this->setstate(__err);
247 }
248 catch(exception& __fail)
249 {
250 // 27.6.1.2.1 Common requirements.
251 // Turn this on without causing an ios::failure to be thrown.
252 this->setstate(ios_base::badbit);
253 if ((this->exceptions() & ios_base::badbit) != 0)
254 __throw_exception_again;
255 }
256 }
257 return *this;
258 }
260 template<typename _CharT, typename _Traits>
261 basic_istream<_CharT, _Traits>&
262 basic_istream<_CharT, _Traits>::
263 operator>>(long& __n)
264 {
265 sentry __cerb(*this, false);
266 if (__cerb)
267 {
268 try
269 {
270 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
271 if (_M_check_facet(_M_fnumget))
272 _M_fnumget->get(*this, 0, *this, __err, __n);
273 this->setstate(__err);
274 }
275 catch(exception& __fail)
276 {
277 // 27.6.1.2.1 Common requirements.
278 // Turn this on without causing an ios::failure to be thrown.
279 this->setstate(ios_base::badbit);
280 if ((this->exceptions() & ios_base::badbit) != 0)
281 __throw_exception_again;
282 }
283 }
284 return *this;
285 }
287 template<typename _CharT, typename _Traits>
288 basic_istream<_CharT, _Traits>&
289 basic_istream<_CharT, _Traits>::
290 operator>>(unsigned long& __n)
291 {
292 sentry __cerb(*this, false);
293 if (__cerb)
294 {
295 try
296 {
297 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
298 if (_M_check_facet(_M_fnumget))
299 _M_fnumget->get(*this, 0, *this, __err, __n);
300 this->setstate(__err);
301 }
302 catch(exception& __fail)
303 {
304 // 27.6.1.2.1 Common requirements.
305 // Turn this on without causing an ios::failure to be thrown.
306 this->setstate(ios_base::badbit);
307 if ((this->exceptions() & ios_base::badbit) != 0)
308 __throw_exception_again;
309 }
310 }
311 return *this;
312 }
314 #ifdef _GLIBCPP_USE_LONG_LONG
315 template<typename _CharT, typename _Traits>
316 basic_istream<_CharT, _Traits>&
317 basic_istream<_CharT, _Traits>::
318 operator>>(long long& __n)
319 {
320 sentry __cerb(*this, false);
321 if (__cerb)
322 {
323 try
324 {
325 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
326 if (_M_check_facet(_M_fnumget))
327 _M_fnumget->get(*this, 0, *this, __err, __n);
328 this->setstate(__err);
329 }
330 catch(exception& __fail)
331 {
332 // 27.6.1.2.1 Common requirements.
333 // Turn this on without causing an ios::failure to be thrown.
334 this->setstate(ios_base::badbit);
335 if ((this->exceptions() & ios_base::badbit) != 0)
336 __throw_exception_again;
337 }
338 }
339 return *this;
340 }
342 template<typename _CharT, typename _Traits>
343 basic_istream<_CharT, _Traits>&
344 basic_istream<_CharT, _Traits>::
345 operator>>(unsigned long long& __n)
346 {
347 sentry __cerb(*this, false);
348 if (__cerb)
349 {
350 try
351 {
352 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
353 if (_M_check_facet(_M_fnumget))
354 _M_fnumget->get(*this, 0, *this, __err, __n);
355 this->setstate(__err);
356 }
357 catch(exception& __fail)
358 {
359 // 27.6.1.2.1 Common requirements.
360 // Turn this on without causing an ios::failure to be thrown.
361 this->setstate(ios_base::badbit);
362 if ((this->exceptions() & ios_base::badbit) != 0)
363 __throw_exception_again;
364 }
365 }
366 return *this;
367 }
368 #endif
370 template<typename _CharT, typename _Traits>
371 basic_istream<_CharT, _Traits>&
372 basic_istream<_CharT, _Traits>::
373 operator>>(float& __n)
374 {
375 sentry __cerb(*this, false);
376 if (__cerb)
377 {
378 try
379 {
380 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
381 if (_M_check_facet(_M_fnumget))
382 _M_fnumget->get(*this, 0, *this, __err, __n);
383 this->setstate(__err);
384 }
385 catch(exception& __fail)
386 {
387 // 27.6.1.2.1 Common requirements.
388 // Turn this on without causing an ios::failure to be thrown.
389 this->setstate(ios_base::badbit);
390 if ((this->exceptions() & ios_base::badbit) != 0)
391 __throw_exception_again;
392 }
393 }
394 return *this;
395 }
397 template<typename _CharT, typename _Traits>
398 basic_istream<_CharT, _Traits>&
399 basic_istream<_CharT, _Traits>::
400 operator>>(double& __n)
401 {
402 sentry __cerb(*this, false);
403 if (__cerb)
404 {
405 try
406 {
407 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
408 if (_M_check_facet(_M_fnumget))
409 _M_fnumget->get(*this, 0, *this, __err, __n);
410 this->setstate(__err);
411 }
412 catch(exception& __fail)
413 {
414 // 27.6.1.2.1 Common requirements.
415 // Turn this on without causing an ios::failure to be thrown.
416 this->setstate(ios_base::badbit);
417 if ((this->exceptions() & ios_base::badbit) != 0)
418 __throw_exception_again;
419 }
420 }
421 return *this;
422 }
424 template<typename _CharT, typename _Traits>
425 basic_istream<_CharT, _Traits>&
426 basic_istream<_CharT, _Traits>::
427 operator>>(long double& __n)
428 {
429 sentry __cerb(*this, false);
430 if (__cerb)
431 {
432 try
433 {
434 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
435 if (_M_check_facet(_M_fnumget))
436 _M_fnumget->get(*this, 0, *this, __err, __n);
437 this->setstate(__err);
438 }
439 catch(exception& __fail)
440 {
441 // 27.6.1.2.1 Common requirements.
442 // Turn this on without causing an ios::failure to be thrown.
443 this->setstate(ios_base::badbit);
444 if ((this->exceptions() & ios_base::badbit) != 0)
445 __throw_exception_again;
446 }
447 }
448 return *this;
449 }
451 template<typename _CharT, typename _Traits>
452 basic_istream<_CharT, _Traits>&
453 basic_istream<_CharT, _Traits>::
454 operator>>(void*& __n)
455 {
456 sentry __cerb(*this, false);
457 if (__cerb)
458 {
459 try
460 {
461 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
462 if (_M_check_facet(_M_fnumget))
463 _M_fnumget->get(*this, 0, *this, __err, __n);
464 this->setstate(__err);
465 }
466 catch(exception& __fail)
467 {
468 // 27.6.1.2.1 Common requirements.
469 // Turn this on without causing an ios::failure to be thrown.
470 this->setstate(ios_base::badbit);
471 if ((this->exceptions() & ios_base::badbit) != 0)
472 __throw_exception_again;
473 }
474 }
475 return *this;
476 }
478 template<typename _CharT, typename _Traits>
479 basic_istream<_CharT, _Traits>&
480 basic_istream<_CharT, _Traits>::
481 operator>>(__streambuf_type* __sbout)
482 {
483 sentry __cerb(*this, false);
484 if (__cerb)
485 {
486 try
487 {
488 streamsize __xtrct = 0;
489 if (__sbout)
490 {
491 __streambuf_type* __sbin = this->rdbuf();
492 __xtrct = __copy_streambufs(*this, __sbin, __sbout);
493 }
494 if (!__sbout || !__xtrct)
495 this->setstate(ios_base::failbit);
496 }
497 catch(exception& __fail)
498 {
499 // 27.6.2.5.1 Common requirements.
500 // Turn this on without causing an ios::failure to be thrown.
501 this->setstate(ios_base::badbit);
502 if ((this->exceptions() & ios_base::badbit) != 0)
503 __throw_exception_again;
504 }
505 }
506 return *this;
507 }
509 template<typename _CharT, typename _Traits>
510 typename basic_istream<_CharT, _Traits>::int_type
511 basic_istream<_CharT, _Traits>::
512 get(void)
513 {
514 const int_type __eof = traits_type::eof();
515 int_type __c = __eof;
516 _M_gcount = 0;
517 sentry __cerb(*this, true);
518 if (__cerb)
519 {
520 try
521 {
522 __c = this->rdbuf()->sbumpc();
523 // 27.6.1.1 paragraph 3
524 if (__c != __eof)
525 _M_gcount = 1;
526 else
527 this->setstate(ios_base::eofbit | ios_base::failbit);
528 }
529 catch(exception& __fail)
530 {
531 // 27.6.1.3 paragraph 1
532 // Turn this on without causing an ios::failure to be thrown.
533 this->setstate(ios_base::badbit);
534 if ((this->exceptions() & ios_base::badbit) != 0)
535 __throw_exception_again;
536 }
537 }
538 return __c;
539 }
541 template<typename _CharT, typename _Traits>
542 basic_istream<_CharT, _Traits>&
543 basic_istream<_CharT, _Traits>::
544 get(char_type& __c)
545 {
546 _M_gcount = 0;
547 sentry __cerb(*this, true);
548 if (__cerb)
549 {
550 try
551 {
552 const int_type __eof = traits_type::eof();
553 int_type __bufval = this->rdbuf()->sbumpc();
554 // 27.6.1.1 paragraph 3
555 if (__bufval != __eof)
556 {
557 _M_gcount = 1;
558 __c = traits_type::to_char_type(__bufval);
559 }
560 else
561 this->setstate(ios_base::eofbit | ios_base::failbit);
562 }
563 catch(exception& __fail)
564 {
565 // 27.6.1.3 paragraph 1
566 // Turn this on without causing an ios::failure to be thrown.
567 this->setstate(ios_base::badbit);
568 if ((this->exceptions() & ios_base::badbit) != 0)
569 __throw_exception_again;
570 }
571 }
572 return *this;
573 }
575 template<typename _CharT, typename _Traits>
576 basic_istream<_CharT, _Traits>&
577 basic_istream<_CharT, _Traits>::
578 get(char_type* __s, streamsize __n, char_type __delim)
579 {
580 _M_gcount = 0;
581 sentry __cerb(*this, true);
582 if (__cerb)
583 {
584 try
585 {
586 const int_type __idelim = traits_type::to_int_type(__delim);
587 const int_type __eof = traits_type::eof();
588 __streambuf_type* __sb = this->rdbuf();
589 int_type __c = __sb->sgetc();
591 while (_M_gcount + 1 < __n && __c != __eof && __c != __idelim)
592 {
593 *__s++ = traits_type::to_char_type(__c);
594 __c = __sb->snextc();
595 ++_M_gcount;
596 }
597 if (__c == __eof)
598 this->setstate(ios_base::eofbit);
599 }
600 catch(exception& __fail)
601 {
602 // 27.6.1.3 paragraph 1
603 // Turn this on without causing an ios::failure to be thrown.
604 this->setstate(ios_base::badbit);
605 if ((this->exceptions() & ios_base::badbit) != 0)
606 __throw_exception_again;
607 }
608 }
609 *__s = char_type();
610 if (!_M_gcount)
611 this->setstate(ios_base::failbit);
612 return *this;
613 }
615 template<typename _CharT, typename _Traits>
616 basic_istream<_CharT, _Traits>&
617 basic_istream<_CharT, _Traits>::
618 get(__streambuf_type& __sb, char_type __delim)
619 {
620 _M_gcount = 0;
621 sentry __cerb(*this, true);
622 if (__cerb)
623 {
624 try
625 {
626 const int_type __idelim = traits_type::to_int_type(__delim);
627 const int_type __eof = traits_type::eof();
628 __streambuf_type* __this_sb = this->rdbuf();
629 int_type __c = __this_sb->sgetc();
631 while (__c != __eof && __c != __idelim
632 && (__sb.sputc(traits_type::to_char_type(__c)) != __eof))
633 {
634 ++_M_gcount;
635 __c = __this_sb->snextc();
636 }
637 if (__c == __eof)
638 this->setstate(ios_base::eofbit);
639 }
640 catch(exception& __fail)
641 {
642 // 27.6.1.3 paragraph 1
643 // Turn this on without causing an ios::failure to be thrown.
644 this->setstate(ios_base::badbit);
645 if ((this->exceptions() & ios_base::badbit) != 0)
646 __throw_exception_again;
647 }
648 }
649 if (!_M_gcount)
650 this->setstate(ios_base::failbit);
651 return *this;
652 }
654 template<typename _CharT, typename _Traits>
655 basic_istream<_CharT, _Traits>&
656 basic_istream<_CharT, _Traits>::
657 getline(char_type* __s, streamsize __n, char_type __delim)
658 {
659 _M_gcount = 0;
660 sentry __cerb(*this, true);
661 if (__cerb)
662 {
663 try
664 {
665 const int_type __idelim = traits_type::to_int_type(__delim);
666 const int_type __eof = traits_type::eof();
667 __streambuf_type* __sb = this->rdbuf();
668 int_type __c = __sb->sgetc();
670 while (_M_gcount + 1 < __n && __c != __eof && __c != __idelim)
671 {
672 *__s++ = traits_type::to_char_type(__c);
673 __c = __sb->snextc();
674 ++_M_gcount;
675 }
676 if (__c == __eof)
677 this->setstate(ios_base::eofbit);
678 else
679 {
680 if (__c == __idelim)
681 {
682 __sb->sbumpc();
683 ++_M_gcount;
684 }
685 else
686 this->setstate(ios_base::failbit);
687 }
688 }
689 catch(exception& __fail)
690 {
691 // 27.6.1.3 paragraph 1
692 // Turn this on without causing an ios::failure to be thrown.
693 this->setstate(ios_base::badbit);
694 if ((this->exceptions() & ios_base::badbit) != 0)
695 __throw_exception_again;
696 }
697 }
698 *__s = char_type();
699 if (!_M_gcount)
700 this->setstate(ios_base::failbit);
701 return *this;
702 }
704 template<typename _CharT, typename _Traits>
705 basic_istream<_CharT, _Traits>&
706 basic_istream<_CharT, _Traits>::
707 ignore(streamsize __n, int_type __delim)
708 {
709 _M_gcount = 0;
710 sentry __cerb(*this, true);
711 if (__cerb)
712 {
713 try
714 {
715 const int_type __eof = traits_type::eof();
716 __streambuf_type* __sb = this->rdbuf();
717 int_type __c = __sb->sgetc();
719 __n = min(__n, numeric_limits<streamsize>::max());
720 while (_M_gcount < __n && __c !=__eof && __c != __delim)
721 {
722 __c = __sb->snextc();
723 ++_M_gcount;
724 }
725 if (__c == __eof)
726 this->setstate(ios_base::eofbit);
727 else if (__c == __delim)
728 {
729 __sb->sbumpc();
730 ++_M_gcount;
731 }
732 }
733 catch(exception& __fail)
734 {
735 // 27.6.1.3 paragraph 1
736 // Turn this on without causing an ios::failure to be thrown.
737 this->setstate(ios_base::badbit);
738 if ((this->exceptions() & ios_base::badbit) != 0)
739 __throw_exception_again;
740 }
741 }
742 return *this;
743 }
745 template<typename _CharT, typename _Traits>
746 typename basic_istream<_CharT, _Traits>::int_type
747 basic_istream<_CharT, _Traits>::
748 peek(void)
749 {
750 int_type __c = traits_type::eof();
751 _M_gcount = 0;
752 sentry __cerb(*this, true);
753 if (__cerb)
754 {
755 try
756 { __c = this->rdbuf()->sgetc(); }
757 catch(exception& __fail)
758 {
759 // 27.6.1.3 paragraph 1
760 // Turn this on without causing an ios::failure to be thrown.
761 this->setstate(ios_base::badbit);
762 if ((this->exceptions() & ios_base::badbit) != 0)
763 __throw_exception_again;
764 }
765 }
766 return __c;
767 }
769 template<typename _CharT, typename _Traits>
770 basic_istream<_CharT, _Traits>&
771 basic_istream<_CharT, _Traits>::
772 read(char_type* __s, streamsize __n)
773 {
774 _M_gcount = 0;
775 sentry __cerb(*this, true);
776 if (__cerb)
777 {
778 try
779 {
780 _M_gcount = this->rdbuf()->sgetn(__s, __n);
781 if (_M_gcount != __n)
782 this->setstate(ios_base::eofbit | ios_base::failbit);
783 }
784 catch(exception& __fail)
785 {
786 // 27.6.1.3 paragraph 1
787 // Turn this on without causing an ios::failure to be thrown.
788 this->setstate(ios_base::badbit);
789 if ((this->exceptions() & ios_base::badbit) != 0)
790 __throw_exception_again;
791 }
792 }
793 else
794 this->setstate(ios_base::failbit);
795 return *this;
796 }
798 template<typename _CharT, typename _Traits>
799 streamsize
800 basic_istream<_CharT, _Traits>::
801 readsome(char_type* __s, streamsize __n)
802 {
803 _M_gcount = 0;
804 sentry __cerb(*this, true);
805 if (__cerb)
806 {
807 try
808 {
809 const int_type __eof = traits_type::eof();
810 streamsize __num = this->rdbuf()->in_avail();
811 if (__num != static_cast<streamsize>(__eof))
812 {
813 __num = min(__num, __n);
814 if (__num)
815 _M_gcount = this->rdbuf()->sgetn(__s, __num);
816 }
817 else
818 this->setstate(ios_base::eofbit);
819 }
820 catch(exception& __fail)
821 {
822 // 27.6.1.3 paragraph 1
823 // Turn this on without causing an ios::failure to be thrown.
824 this->setstate(ios_base::badbit);
825 if ((this->exceptions() & ios_base::badbit) != 0)
826 __throw_exception_again;
827 }
828 }
829 else
830 this->setstate(ios_base::failbit);
831 return _M_gcount;
832 }
834 template<typename _CharT, typename _Traits>
835 basic_istream<_CharT, _Traits>&
836 basic_istream<_CharT, _Traits>::
837 putback(char_type __c)
838 {
839 sentry __cerb(*this, true);
840 if (__cerb)
841 {
842 try
843 {
844 const int_type __eof = traits_type::eof();
845 __streambuf_type* __sb = this->rdbuf();
846 if (!__sb || __sb->sputbackc(__c) == __eof)
847 this->setstate(ios_base::badbit);
848 }
849 catch(exception& __fail)
850 {
851 // 27.6.1.3 paragraph 1
852 // Turn this on without causing an ios::failure to be thrown.
853 this->setstate(ios_base::badbit);
854 if ((this->exceptions() & ios_base::badbit) != 0)
855 __throw_exception_again;
856 }
857 }
858 else
859 this->setstate(ios_base::failbit);
860 return *this;
861 }
863 template<typename _CharT, typename _Traits>
864 basic_istream<_CharT, _Traits>&
865 basic_istream<_CharT, _Traits>::
866 unget(void)
867 {
868 _M_gcount = 0;
869 sentry __cerb(*this, true);
870 if (__cerb)
871 {
872 try
873 {
874 const int_type __eof = traits_type::eof();
875 __streambuf_type* __sb = this->rdbuf();
876 if (!__sb || __eof == __sb->sungetc())
877 this->setstate(ios_base::badbit);
878 }
879 catch(exception& __fail)
880 {
881 // 27.6.1.3 paragraph 1
882 // Turn this on without causing an ios::failure to be thrown.
883 this->setstate(ios_base::badbit);
884 if ((this->exceptions() & ios_base::badbit) != 0)
885 __throw_exception_again;
886 }
887 }
888 else
889 this->setstate(ios_base::failbit);
890 return *this;
891 }
893 template<typename _CharT, typename _Traits>
894 int
895 basic_istream<_CharT, _Traits>::
896 sync(void)
897 {
898 int __ret = traits_type::eof();
899 _M_gcount = 0;
900 sentry __cerb(*this, true);
901 if (__cerb)
902 {
903 try
904 {
905 __streambuf_type* __sb = this->rdbuf();
906 if (!__sb || __ret == __sb->pubsync())
907 this->setstate(ios_base::badbit);
908 else
909 __ret = 0;
910 }
911 catch(exception& __fail)
912 {
913 // 27.6.1.3 paragraph 1
914 // Turn this on without causing an ios::failure to be thrown.
915 this->setstate(ios_base::badbit);
916 if ((this->exceptions() & ios_base::badbit) != 0)
917 __throw_exception_again;
918 }
919 }
920 return __ret;
921 }
923 template<typename _CharT, typename _Traits>
924 typename basic_istream<_CharT, _Traits>::pos_type
925 basic_istream<_CharT, _Traits>::
926 tellg(void)
927 {
928 pos_type __ret = pos_type(-1);
929 _M_gcount = 0;
930 sentry __cerb(*this, true);
931 if (__cerb)
932 {
933 try
934 {
935 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
936 }
937 catch(exception& __fail)
938 {
939 // 27.6.1.3 paragraph 1
940 // Turn this on without causing an ios::failure to be thrown.
941 this->setstate(ios_base::badbit);
942 if ((this->exceptions() & ios_base::badbit) != 0)
943 __throw_exception_again;
944 }
945 }
946 return __ret;
947 }
950 template<typename _CharT, typename _Traits>
951 basic_istream<_CharT, _Traits>&
952 basic_istream<_CharT, _Traits>::
953 seekg(pos_type __pos)
954 {
955 _M_gcount = 0;
956 sentry __cerb(*this, true);
957 if (__cerb)
958 {
959 try
960 {
961 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
962 // 136. seekp, seekg setting wrong streams?
963 pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::in);
965 // 129. Need error indication from seekp() and seekg()
966 if (__err == pos_type(off_type(-1)))
967 this->setstate(ios_base::failbit);
968 #endif
969 }
970 catch(exception& __fail)
971 {
972 // 27.6.1.3 paragraph 1
973 // Turn this on without causing an ios::failure to be thrown.
974 this->setstate(ios_base::badbit);
975 if ((this->exceptions() & ios_base::badbit) != 0)
976 __throw_exception_again;
977 }
978 }
979 return *this;
980 }
982 template<typename _CharT, typename _Traits>
983 basic_istream<_CharT, _Traits>&
984 basic_istream<_CharT, _Traits>::
985 seekg(off_type __off, ios_base::seekdir __dir)
986 {
987 _M_gcount = 0;
988 sentry __cerb(*this, true);
989 if (__cerb)
990 {
991 try
992 {
993 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
994 // 136. seekp, seekg setting wrong streams?
995 pos_type __err = this->rdbuf()->pubseekoff(__off, __dir,
996 ios_base::in);
998 // 129. Need error indication from seekp() and seekg()
999 if (__err == pos_type(off_type(-1)))
1000 this->setstate(ios_base::failbit);
1001 #endif
1002 }
1003 catch(exception& __fail)
1004 {
1005 // 27.6.1.3 paragraph 1
1006 // Turn this on without causing an ios::failure to be thrown.
1007 this->setstate(ios_base::badbit);
1008 if ((this->exceptions() & ios_base::badbit) != 0)
1009 __throw_exception_again;
1010 }
1011 }
1012 return *this;
1013 }
1015 // 27.6.1.2.3 Character extraction templates
1016 template<typename _CharT, typename _Traits>
1017 basic_istream<_CharT, _Traits>&
1018 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
1019 {
1020 typedef basic_istream<_CharT, _Traits> __istream_type;
1021 typename __istream_type::sentry __cerb(__in, false);
1022 if (__cerb)
1023 {
1024 try
1025 { __in.get(__c); }
1026 catch(exception& __fail)
1027 {
1028 // 27.6.1.2.1 Common requirements.
1029 // Turn this on without causing an ios::failure to be thrown.
1030 __in.setstate(ios_base::badbit);
1031 if ((__in.exceptions() & ios_base::badbit) != 0)
1032 __throw_exception_again;
1033 }
1034 }
1035 else
1036 __in.setstate(ios_base::failbit);
1037 return __in;
1038 }
1040 template<typename _CharT, typename _Traits>
1041 basic_istream<_CharT, _Traits>&
1042 operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
1043 {
1044 typedef basic_istream<_CharT, _Traits> __istream_type;
1045 typedef typename __istream_type::__streambuf_type __streambuf_type;
1046 typedef typename _Traits::int_type int_type;
1047 typedef _CharT char_type;
1048 typedef ctype<_CharT> __ctype_type;
1049 streamsize __extracted = 0;
1051 typename __istream_type::sentry __cerb(__in, false);
1052 if (__cerb)
1053 {
1054 try
1055 {
1056 // Figure out how many characters to extract.
1057 streamsize __num = __in.width();
1058 if (__num == 0)
1059 __num = numeric_limits<streamsize>::max();
1061 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1062 const int_type __eof = _Traits::eof();
1063 __streambuf_type* __sb = __in.rdbuf();
1064 int_type __c = __sb->sgetc();
1066 while (__extracted < __num - 1
1067 && __c != __eof && !__ctype.is(ctype_base::space, __c))
1068 {
1069 *__s++ = __c;
1070 ++__extracted;
1071 __c = __sb->snextc();
1072 }
1073 if (__c == __eof)
1074 __in.setstate(ios_base::eofbit);
1076 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1077 //68. Extractors for char* should store null at end
1078 *__s = char_type();
1079 #endif
1080 __in.width(0);
1081 }
1082 catch(exception& __fail)
1083 {
1084 // 27.6.1.2.1 Common requirements.
1085 // Turn this on without causing an ios::failure to be thrown.
1086 __in.setstate(ios_base::badbit);
1087 if ((__in.exceptions() & ios_base::badbit) != 0)
1088 __throw_exception_again;
1089 }
1090 }
1091 if (!__extracted)
1092 __in.setstate(ios_base::failbit);
1093 return __in;
1094 }
1096 // 27.6.1.4 Standard basic_istream manipulators
1097 template<typename _CharT, typename _Traits>
1098 basic_istream<_CharT,_Traits>&
1099 ws(basic_istream<_CharT,_Traits>& __in)
1100 {
1101 typedef basic_istream<_CharT, _Traits> __istream_type;
1102 typedef typename __istream_type::__streambuf_type __streambuf_type;
1103 typedef typename __istream_type::__ctype_type __ctype_type;
1104 typedef typename __istream_type::int_type __int_type;
1106 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1107 const __int_type __eof = _Traits::eof();
1108 __streambuf_type* __sb = __in.rdbuf();
1109 __int_type __c = __sb->sgetc();
1111 while (__c != __eof && __ctype.is(ctype_base::space, __c))
1112 __c = __sb->snextc();
1113 if (__c == __eof)
1114 __in.setstate(ios_base::eofbit);
1116 return __in;
1117 }
1119 // 21.3.7.9 basic_string::getline and operators
1120 template<typename _CharT, typename _Traits, typename _Alloc>
1121 basic_istream<_CharT, _Traits>&
1122 operator>>(basic_istream<_CharT, _Traits>& __in,
1123 basic_string<_CharT, _Traits, _Alloc>& __str)
1124 {
1125 typedef basic_istream<_CharT, _Traits> __istream_type;
1126 typedef typename __istream_type::int_type __int_type;
1127 typedef typename __istream_type::__streambuf_type __streambuf_type;
1128 typedef typename __istream_type::__ctype_type __ctype_type;
1129 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
1130 typedef typename __string_type::size_type __size_type;
1131 __size_type __extracted = 0;
1133 typename __istream_type::sentry __cerb(__in, false);
1134 if (__cerb)
1135 {
1136 __str.erase();
1137 streamsize __w = __in.width();
1138 __size_type __n;
1139 __n = __w > 0 ? static_cast<__size_type>(__w) : __str.max_size();
1141 const __ctype_type& __ctype = use_facet<__ctype_type>(__in.getloc());
1142 const __int_type __eof = _Traits::eof();
1143 __streambuf_type* __sb = __in.rdbuf();
1144 __int_type __c = __sb->sgetc();
1146 while (__extracted < __n
1147 && __c != __eof && !__ctype.is(ctype_base::space, __c))
1148 {
1149 __str += _Traits::to_char_type(__c);
1150 ++__extracted;
1151 __c = __sb->snextc();
1152 }
1153 if (__c == __eof)
1154 __in.setstate(ios_base::eofbit);
1155 __in.width(0);
1156 }
1157 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
1158 //211. operator>>(istream&, string&) doesn't set failbit
1159 if (!__extracted)
1160 __in.setstate (ios_base::failbit);
1161 #endif
1162 return __in;
1163 }
1165 template<typename _CharT, typename _Traits, typename _Alloc>
1166 basic_istream<_CharT, _Traits>&
1167 getline(basic_istream<_CharT, _Traits>& __in,
1168 basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
1169 {
1170 typedef basic_istream<_CharT, _Traits> __istream_type;
1171 typedef typename __istream_type::int_type __int_type;
1172 typedef typename __istream_type::__streambuf_type __streambuf_type;
1173 typedef typename __istream_type::__ctype_type __ctype_type;
1174 typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
1175 typedef typename __string_type::size_type __size_type;
1177 __size_type __extracted = 0;
1178 bool __testdelim = false;
1179 typename __istream_type::sentry __cerb(__in, true);
1180 if (__cerb)
1181 {
1182 __str.erase();
1183 __size_type __n = __str.max_size();
1185 __int_type __idelim = _Traits::to_int_type(__delim);
1186 __streambuf_type* __sb = __in.rdbuf();
1187 __int_type __c = __sb->sbumpc();
1188 const __int_type __eof = _Traits::eof();
1189 __testdelim = __c == __idelim;
1191 while (__extracted <= __n && __c != __eof && !__testdelim)
1192 {
1193 __str += _Traits::to_char_type(__c);
1194 ++__extracted;
1195 __c = __sb->sbumpc();
1196 __testdelim = __c == __idelim;
1197 }
1198 if (__c == __eof)
1199 __in.setstate(ios_base::eofbit);
1200 }
1201 if (!__extracted && !__testdelim)
1202 __in.setstate(ios_base::failbit);
1203 return __in;
1204 }
1206 template<class _CharT, class _Traits, class _Alloc>
1207 inline basic_istream<_CharT,_Traits>&
1208 getline(basic_istream<_CharT, _Traits>& __in,
1209 basic_string<_CharT,_Traits,_Alloc>& __str)
1210 { return getline(__in, __str, __in.widen('\n')); }
1212 // Inhibit implicit instantiations for required instantiations,
1213 // which are defined via explicit instantiations elsewhere.
1214 // NB: This syntax is a GNU extension.
1215 extern template class basic_istream<char>;
1216 extern template istream& ws(istream&);
1217 extern template istream& operator>>(istream&, char&);
1218 extern template istream& operator>>(istream&, char*);
1219 extern template istream& operator>>(istream&, unsigned char&);
1220 extern template istream& operator>>(istream&, signed char&);
1221 extern template istream& operator>>(istream&, unsigned char*);
1222 extern template istream& operator>>(istream&, signed char*);
1224 #ifdef _GLIBCPP_USE_WCHAR_T
1225 extern template class basic_istream<wchar_t>;
1226 extern template wistream& ws(wistream&);
1227 extern template wistream& operator>>(wistream&, wchar_t&);
1228 extern template wistream& operator>>(wistream&, wchar_t*);
1229 #endif
1230 } // namespace std