1 : // istream classes -*- C++ -*-
2 :
3 : // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 : // 2006, 2007, 2008, 2009
5 : // Free Software Foundation, Inc.
6 : //
7 : // This file is part of the GNU ISO C++ Library. This library is free
8 : // software; you can redistribute it and/or modify it under the
9 : // terms of the GNU General Public License as published by the
10 : // Free Software Foundation; either version 3, or (at your option)
11 : // any later version.
12 :
13 : // This library is distributed in the hope that it will be useful,
14 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 : // GNU General Public License for more details.
17 :
18 : // Under Section 7 of GPL version 3, you are granted additional
19 : // permissions described in the GCC Runtime Library Exception, version
20 : // 3.1, as published by the Free Software Foundation.
21 :
22 : // You should have received a copy of the GNU General Public License and
23 : // a copy of the GCC Runtime Library Exception along with this program;
24 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25 : // <http://www.gnu.org/licenses/>.
26 :
27 : /** @file istream.tcc
28 : * This is an internal header file, included by other library headers.
29 : * You should not attempt to use it directly.
30 : */
31 :
32 : //
33 : // ISO C++ 14882: 27.6.1 Input streams
34 : //
35 :
36 : #ifndef _ISTREAM_TCC
37 : #define _ISTREAM_TCC 1
38 :
39 : #pragma GCC system_header
40 :
41 : #include <cxxabi-forced.h>
42 :
43 : _GLIBCXX_BEGIN_NAMESPACE(std)
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 0 : basic_istream<_CharT, _Traits>::
87 : _M_extract(_ValueT& __v)
88 : {
89 0 : sentry __cerb(*this, false);
90 0 : if (__cerb)
91 : {
92 0 : ios_base::iostate __err = ios_base::goodbit;
93 : __try
94 : {
95 0 : const __num_get_type& __ng = __check_facet(this->_M_num_get);
96 0 : __ng.get(*this, 0, *this, __err, __v);
97 : }
98 0 : __catch(__cxxabiv1::__forced_unwind&)
99 : {
100 0 : this->_M_setstate(ios_base::badbit);
101 0 : __throw_exception_again;
102 : }
103 0 : __catch(...)
104 0 : { this->_M_setstate(ios_base::badbit); }
105 0 : if (__err)
106 0 : this->setstate(__err);
107 : }
108 0 : 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 : sentry __cerb(*this, true);
717 : if (__cerb)
718 : {
719 : ios_base::iostate __err = ios_base::goodbit;
720 : __try
721 : {
722 : const int_type __eof = traits_type::eof();
723 : __streambuf_type* __sb = this->rdbuf();
724 : if (!__sb
725 : || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
726 : __err |= ios_base::badbit;
727 : }
728 : __catch(__cxxabiv1::__forced_unwind&)
729 : {
730 : this->_M_setstate(ios_base::badbit);
731 : __throw_exception_again;
732 : }
733 : __catch(...)
734 : { this->_M_setstate(ios_base::badbit); }
735 : if (__err)
736 : this->setstate(__err);
737 : }
738 : return *this;
739 : }
740 :
741 : template<typename _CharT, typename _Traits>
742 : basic_istream<_CharT, _Traits>&
743 : basic_istream<_CharT, _Traits>::
744 : unget(void)
745 : {
746 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
747 : // 60. What is a formatted input function?
748 : _M_gcount = 0;
749 : sentry __cerb(*this, true);
750 : if (__cerb)
751 : {
752 : ios_base::iostate __err = ios_base::goodbit;
753 : __try
754 : {
755 : const int_type __eof = traits_type::eof();
756 : __streambuf_type* __sb = this->rdbuf();
757 : if (!__sb
758 : || traits_type::eq_int_type(__sb->sungetc(), __eof))
759 : __err |= ios_base::badbit;
760 : }
761 : __catch(__cxxabiv1::__forced_unwind&)
762 : {
763 : this->_M_setstate(ios_base::badbit);
764 : __throw_exception_again;
765 : }
766 : __catch(...)
767 : { this->_M_setstate(ios_base::badbit); }
768 : if (__err)
769 : this->setstate(__err);
770 : }
771 : return *this;
772 : }
773 :
774 : template<typename _CharT, typename _Traits>
775 : int
776 : basic_istream<_CharT, _Traits>::
777 : sync(void)
778 : {
779 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
780 : // DR60. Do not change _M_gcount.
781 : int __ret = -1;
782 : sentry __cerb(*this, true);
783 : if (__cerb)
784 : {
785 : ios_base::iostate __err = ios_base::goodbit;
786 : __try
787 : {
788 : __streambuf_type* __sb = this->rdbuf();
789 : if (__sb)
790 : {
791 : if (__sb->pubsync() == -1)
792 : __err |= ios_base::badbit;
793 : else
794 : __ret = 0;
795 : }
796 : }
797 : __catch(__cxxabiv1::__forced_unwind&)
798 : {
799 : this->_M_setstate(ios_base::badbit);
800 : __throw_exception_again;
801 : }
802 : __catch(...)
803 : { this->_M_setstate(ios_base::badbit); }
804 : if (__err)
805 : this->setstate(__err);
806 : }
807 : return __ret;
808 : }
809 :
810 : template<typename _CharT, typename _Traits>
811 : typename basic_istream<_CharT, _Traits>::pos_type
812 : basic_istream<_CharT, _Traits>::
813 : tellg(void)
814 : {
815 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
816 : // DR60. Do not change _M_gcount.
817 : pos_type __ret = pos_type(-1);
818 : __try
819 : {
820 : if (!this->fail())
821 : __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
822 : ios_base::in);
823 : }
824 : __catch(__cxxabiv1::__forced_unwind&)
825 : {
826 : this->_M_setstate(ios_base::badbit);
827 : __throw_exception_again;
828 : }
829 : __catch(...)
830 : { this->_M_setstate(ios_base::badbit); }
831 : return __ret;
832 : }
833 :
834 : template<typename _CharT, typename _Traits>
835 : basic_istream<_CharT, _Traits>&
836 : basic_istream<_CharT, _Traits>::
837 : seekg(pos_type __pos)
838 : {
839 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
840 : // DR60. Do not change _M_gcount.
841 : ios_base::iostate __err = ios_base::goodbit;
842 : __try
843 : {
844 : if (!this->fail())
845 : {
846 : // 136. seekp, seekg setting wrong streams?
847 : const pos_type __p = this->rdbuf()->pubseekpos(__pos,
848 : ios_base::in);
849 :
850 : // 129. Need error indication from seekp() and seekg()
851 : if (__p == pos_type(off_type(-1)))
852 : __err |= ios_base::failbit;
853 : }
854 : }
855 : __catch(__cxxabiv1::__forced_unwind&)
856 : {
857 : this->_M_setstate(ios_base::badbit);
858 : __throw_exception_again;
859 : }
860 : __catch(...)
861 : { this->_M_setstate(ios_base::badbit); }
862 : if (__err)
863 : this->setstate(__err);
864 : return *this;
865 : }
866 :
867 : template<typename _CharT, typename _Traits>
868 : basic_istream<_CharT, _Traits>&
869 : basic_istream<_CharT, _Traits>::
870 : seekg(off_type __off, ios_base::seekdir __dir)
871 : {
872 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
873 : // DR60. Do not change _M_gcount.
874 : ios_base::iostate __err = ios_base::goodbit;
875 : __try
876 : {
877 : if (!this->fail())
878 : {
879 : // 136. seekp, seekg setting wrong streams?
880 : const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
881 : ios_base::in);
882 :
883 : // 129. Need error indication from seekp() and seekg()
884 : if (__p == pos_type(off_type(-1)))
885 : __err |= ios_base::failbit;
886 : }
887 : }
888 : __catch(__cxxabiv1::__forced_unwind&)
889 : {
890 : this->_M_setstate(ios_base::badbit);
891 : __throw_exception_again;
892 : }
893 : __catch(...)
894 : { this->_M_setstate(ios_base::badbit); }
895 : if (__err)
896 : this->setstate(__err);
897 : return *this;
898 : }
899 :
900 : // 27.6.1.2.3 Character extraction templates
901 : template<typename _CharT, typename _Traits>
902 : basic_istream<_CharT, _Traits>&
903 : operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
904 : {
905 : typedef basic_istream<_CharT, _Traits> __istream_type;
906 : typedef typename __istream_type::int_type __int_type;
907 :
908 : typename __istream_type::sentry __cerb(__in, false);
909 : if (__cerb)
910 : {
911 : ios_base::iostate __err = ios_base::goodbit;
912 : __try
913 : {
914 : const __int_type __cb = __in.rdbuf()->sbumpc();
915 : if (!_Traits::eq_int_type(__cb, _Traits::eof()))
916 : __c = _Traits::to_char_type(__cb);
917 : else
918 : __err |= (ios_base::eofbit | ios_base::failbit);
919 : }
920 : __catch(__cxxabiv1::__forced_unwind&)
921 : {
922 : __in._M_setstate(ios_base::badbit);
923 : __throw_exception_again;
924 : }
925 : __catch(...)
926 : { __in._M_setstate(ios_base::badbit); }
927 : if (__err)
928 : __in.setstate(__err);
929 : }
930 : return __in;
931 : }
932 :
933 : template<typename _CharT, typename _Traits>
934 : basic_istream<_CharT, _Traits>&
935 : operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
936 : {
937 : typedef basic_istream<_CharT, _Traits> __istream_type;
938 : typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
939 : typedef typename _Traits::int_type int_type;
940 : typedef _CharT char_type;
941 : typedef ctype<_CharT> __ctype_type;
942 :
943 : streamsize __extracted = 0;
944 : ios_base::iostate __err = ios_base::goodbit;
945 : typename __istream_type::sentry __cerb(__in, false);
946 : if (__cerb)
947 : {
948 : __try
949 : {
950 : // Figure out how many characters to extract.
951 : streamsize __num = __in.width();
952 : if (__num <= 0)
953 : __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
954 :
955 : const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
956 :
957 : const int_type __eof = _Traits::eof();
958 : __streambuf_type* __sb = __in.rdbuf();
959 : int_type __c = __sb->sgetc();
960 :
961 : while (__extracted < __num - 1
962 : && !_Traits::eq_int_type(__c, __eof)
963 : && !__ct.is(ctype_base::space,
964 : _Traits::to_char_type(__c)))
965 : {
966 : *__s++ = _Traits::to_char_type(__c);
967 : ++__extracted;
968 : __c = __sb->snextc();
969 : }
970 : if (_Traits::eq_int_type(__c, __eof))
971 : __err |= ios_base::eofbit;
972 :
973 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
974 : // 68. Extractors for char* should store null at end
975 : *__s = char_type();
976 : __in.width(0);
977 : }
978 : __catch(__cxxabiv1::__forced_unwind&)
979 : {
980 : __in._M_setstate(ios_base::badbit);
981 : __throw_exception_again;
982 : }
983 : __catch(...)
984 : { __in._M_setstate(ios_base::badbit); }
985 : }
986 : if (!__extracted)
987 : __err |= ios_base::failbit;
988 : if (__err)
989 : __in.setstate(__err);
990 : return __in;
991 : }
992 :
993 : // 27.6.1.4 Standard basic_istream manipulators
994 : template<typename _CharT, typename _Traits>
995 : basic_istream<_CharT, _Traits>&
996 : ws(basic_istream<_CharT, _Traits>& __in)
997 : {
998 : typedef basic_istream<_CharT, _Traits> __istream_type;
999 : typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
1000 : typedef typename __istream_type::int_type __int_type;
1001 : typedef ctype<_CharT> __ctype_type;
1002 :
1003 : const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1004 : const __int_type __eof = _Traits::eof();
1005 : __streambuf_type* __sb = __in.rdbuf();
1006 : __int_type __c = __sb->sgetc();
1007 :
1008 : while (!_Traits::eq_int_type(__c, __eof)
1009 : && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1010 : __c = __sb->snextc();
1011 :
1012 : if (_Traits::eq_int_type(__c, __eof))
1013 : __in.setstate(ios_base::eofbit);
1014 : return __in;
1015 : }
1016 :
1017 : // Inhibit implicit instantiations for required instantiations,
1018 : // which are defined via explicit instantiations elsewhere.
1019 : // NB: This syntax is a GNU extension.
1020 : #if _GLIBCXX_EXTERN_TEMPLATE
1021 : extern template class basic_istream<char>;
1022 : extern template istream& ws(istream&);
1023 : extern template istream& operator>>(istream&, char&);
1024 : extern template istream& operator>>(istream&, char*);
1025 : extern template istream& operator>>(istream&, unsigned char&);
1026 : extern template istream& operator>>(istream&, signed char&);
1027 : extern template istream& operator>>(istream&, unsigned char*);
1028 : extern template istream& operator>>(istream&, signed char*);
1029 :
1030 : extern template istream& istream::_M_extract(unsigned short&);
1031 : extern template istream& istream::_M_extract(unsigned int&);
1032 : extern template istream& istream::_M_extract(long&);
1033 : extern template istream& istream::_M_extract(unsigned long&);
1034 : extern template istream& istream::_M_extract(bool&);
1035 : #ifdef _GLIBCXX_USE_LONG_LONG
1036 : extern template istream& istream::_M_extract(long long&);
1037 : extern template istream& istream::_M_extract(unsigned long long&);
1038 : #endif
1039 : extern template istream& istream::_M_extract(float&);
1040 : extern template istream& istream::_M_extract(double&);
1041 : extern template istream& istream::_M_extract(long double&);
1042 : extern template istream& istream::_M_extract(void*&);
1043 :
1044 : extern template class basic_iostream<char>;
1045 :
1046 : #ifdef _GLIBCXX_USE_WCHAR_T
1047 : extern template class basic_istream<wchar_t>;
1048 : extern template wistream& ws(wistream&);
1049 : extern template wistream& operator>>(wistream&, wchar_t&);
1050 : extern template wistream& operator>>(wistream&, wchar_t*);
1051 :
1052 : extern template wistream& wistream::_M_extract(unsigned short&);
1053 : extern template wistream& wistream::_M_extract(unsigned int&);
1054 : extern template wistream& wistream::_M_extract(long&);
1055 : extern template wistream& wistream::_M_extract(unsigned long&);
1056 : extern template wistream& wistream::_M_extract(bool&);
1057 : #ifdef _GLIBCXX_USE_LONG_LONG
1058 : extern template wistream& wistream::_M_extract(long long&);
1059 : extern template wistream& wistream::_M_extract(unsigned long long&);
1060 : #endif
1061 : extern template wistream& wistream::_M_extract(float&);
1062 : extern template wistream& wistream::_M_extract(double&);
1063 : extern template wistream& wistream::_M_extract(long double&);
1064 : extern template wistream& wistream::_M_extract(void*&);
1065 :
1066 : extern template class basic_iostream<wchar_t>;
1067 : #endif
1068 : #endif
1069 :
1070 : _GLIBCXX_END_NAMESPACE
1071 :
1072 : #endif
|