?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge from mainline (167278:168000).
[official-gcc/graphite-test-results.git] / libstdc++-v3 / src / istream.cc
blobe4102779aa883c70246b253080e974f19355c7bb
1 // Input streams -*- C++ -*-
2
3 // Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009
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 3, or (at your option)
10 // any later version.
11
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.
16
17 // Under Section 7 of GPL version 3, you are granted additional
18 // permissions described in the GCC Runtime Library Exception, version
19 // 3.1, as published by the Free Software Foundation.
20
21 // You should have received a copy of the GNU General Public License and
22 // a copy of the GCC Runtime Library Exception along with this program;
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 // <http://www.gnu.org/licenses/>.
25
26 //
27 // ISO C++ 14882: 27.6.1 Input streams
28 //
29
30 #include <istream>
31
32 _GLIBCXX_BEGIN_NAMESPACE(std)
33
34 template<>
35 basic_istream<char>&
36 basic_istream<char>::
37 getline(char_type* __s, streamsize __n, char_type __delim)
38 {
39 _M_gcount = 0;
40 ios_base::iostate __err = ios_base::goodbit;
41 sentry __cerb(*this, true);
42 if (__cerb)
43 {
44 __try
45 {
46 const int_type __idelim = traits_type::to_int_type(__delim);
47 const int_type __eof = traits_type::eof();
48 __streambuf_type* __sb = this->rdbuf();
49 int_type __c = __sb->sgetc();
50
51 while (_M_gcount + 1 < __n
52 && !traits_type::eq_int_type(__c, __eof)
53 && !traits_type::eq_int_type(__c, __idelim))
54 {
55 streamsize __size = std::min(streamsize(__sb->egptr()
56 - __sb->gptr()),
57 streamsize(__n - _M_gcount
58 - 1));
59 if (__size > 1)
60 {
61 const char_type* __p = traits_type::find(__sb->gptr(),
62 __size,
63 __delim);
64 if (__p)
65 __size = __p - __sb->gptr();
66 traits_type::copy(__s, __sb->gptr(), __size);
67 __s += __size;
68 __sb->gbump(__size);
69 _M_gcount += __size;
70 __c = __sb->sgetc();
71 }
72 else
73 {
74 *__s++ = traits_type::to_char_type(__c);
75 ++_M_gcount;
76 __c = __sb->snextc();
77 }
78 }
79
80 if (traits_type::eq_int_type(__c, __eof))
81 __err |= ios_base::eofbit;
82 else if (traits_type::eq_int_type(__c, __idelim))
83 {
84 ++_M_gcount;
85 __sb->sbumpc();
86 }
87 else
88 __err |= ios_base::failbit;
89 }
90 __catch(__cxxabiv1::__forced_unwind&)
91 {
92 this->_M_setstate(ios_base::badbit);
93 __throw_exception_again;
94 }
95 __catch(...)
96 { this->_M_setstate(ios_base::badbit); }
97 }
98 // _GLIBCXX_RESOLVE_LIB_DEFECTS
99 // 243. get and getline when sentry reports failure.
100 if (__n > 0)
101 *__s = char_type();
102 if (!_M_gcount)
103 __err |= ios_base::failbit;
104 if (__err)
105 this->setstate(__err);
106 return *this;
107 }
108
109 template<>
110 basic_istream<char>&
111 basic_istream<char>::
112 ignore(streamsize __n, int_type __delim)
113 {
114 if (traits_type::eq_int_type(__delim, traits_type::eof()))
115 return ignore(__n);
116
117 _M_gcount = 0;
118 sentry __cerb(*this, true);
119 if (__n > 0 && __cerb)
120 {
121 ios_base::iostate __err = ios_base::goodbit;
122 __try
123 {
124 const char_type __cdelim = traits_type::to_char_type(__delim);
125 const int_type __eof = traits_type::eof();
126 __streambuf_type* __sb = this->rdbuf();
127 int_type __c = __sb->sgetc();
128
129 bool __large_ignore = false;
130 while (true)
131 {
132 while (_M_gcount < __n
133 && !traits_type::eq_int_type(__c, __eof)
134 && !traits_type::eq_int_type(__c, __delim))
135 {
136 streamsize __size = std::min(streamsize(__sb->egptr()
137 - __sb->gptr()),
138 streamsize(__n - _M_gcount));
139 if (__size > 1)
140 {
141 const char_type* __p = traits_type::find(__sb->gptr(),
142 __size,
143 __cdelim);
144 if (__p)
145 __size = __p - __sb->gptr();
146 __sb->gbump(__size);
147 _M_gcount += __size;
148 __c = __sb->sgetc();
149 }
150 else
151 {
152 ++_M_gcount;
153 __c = __sb->snextc();
154 }
155 }
156 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
157 && !traits_type::eq_int_type(__c, __eof)
158 && !traits_type::eq_int_type(__c, __delim))
159 {
160 _M_gcount =
161 __gnu_cxx::__numeric_traits<streamsize>::__min;
162 __large_ignore = true;
163 }
164 else
165 break;
166 }
167
168 if (__large_ignore)
169 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
170
171 if (traits_type::eq_int_type(__c, __eof))
172 __err |= ios_base::eofbit;
173 else if (traits_type::eq_int_type(__c, __delim))
174 {
175 if (_M_gcount
176 < __gnu_cxx::__numeric_traits<streamsize>::__max)
177 ++_M_gcount;
178 __sb->sbumpc();
179 }
180 }
181 __catch(__cxxabiv1::__forced_unwind&)
182 {
183 this->_M_setstate(ios_base::badbit);
184 __throw_exception_again;
185 }
186 __catch(...)
187 { this->_M_setstate(ios_base::badbit); }
188 if (__err)
189 this->setstate(__err);
190 }
191 return *this;
192 }
193
194 template<>
195 basic_istream<char>&
196 operator>>(basic_istream<char>& __in, char* __s)
197 {
198 typedef basic_istream<char> __istream_type;
199 typedef __istream_type::int_type __int_type;
200 typedef __istream_type::char_type __char_type;
201 typedef __istream_type::traits_type __traits_type;
202 typedef __istream_type::__streambuf_type __streambuf_type;
203 typedef __istream_type::__ctype_type __ctype_type;
204
205 streamsize __extracted = 0;
206 ios_base::iostate __err = ios_base::goodbit;
207 __istream_type::sentry __cerb(__in, false);
208 if (__cerb)
209 {
210 __try
211 {
212 // Figure out how many characters to extract.
213 streamsize __num = __in.width();
214 if (__num <= 0)
215 __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
216
217 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
218
219 const __int_type __eof = __traits_type::eof();
220 __streambuf_type* __sb = __in.rdbuf();
221 __int_type __c = __sb->sgetc();
222
223 while (__extracted < __num - 1
224 && !__traits_type::eq_int_type(__c, __eof)
225 && !__ct.is(ctype_base::space,
226 __traits_type::to_char_type(__c)))
227 {
228 streamsize __size = std::min(streamsize(__sb->egptr()
229 - __sb->gptr()),
230 streamsize(__num - __extracted
231 - 1));
232 if (__size > 1)
233 {
234 __size = (__ct.scan_is(ctype_base::space,
235 __sb->gptr() + 1,
236 __sb->gptr() + __size)
237 - __sb->gptr());
238 __traits_type::copy(__s, __sb->gptr(), __size);
239 __s += __size;
240 __sb->gbump(__size);
241 __extracted += __size;
242 __c = __sb->sgetc();
243 }
244 else
245 {
246 *__s++ = __traits_type::to_char_type(__c);
247 ++__extracted;
248 __c = __sb->snextc();
249 }
250 }
251
252 if (__traits_type::eq_int_type(__c, __eof))
253 __err |= ios_base::eofbit;
254
255 // _GLIBCXX_RESOLVE_LIB_DEFECTS
256 // 68. Extractors for char* should store null at end
257 *__s = __char_type();
258 __in.width(0);
259 }
260 __catch(__cxxabiv1::__forced_unwind&)
261 {
262 __in._M_setstate(ios_base::badbit);
263 __throw_exception_again;
264 }
265 __catch(...)
266 { __in._M_setstate(ios_base::badbit); }
267 }
268 if (!__extracted)
269 __err |= ios_base::failbit;
270 if (__err)
271 __in.setstate(__err);
272 return __in;
273 }
274
275 template<>
276 basic_istream<char>&
277 operator>>(basic_istream<char>& __in, basic_string<char>& __str)
278 {
279 typedef basic_istream<char> __istream_type;
280 typedef __istream_type::int_type __int_type;
281 typedef __istream_type::char_type __char_type;
282 typedef __istream_type::traits_type __traits_type;
283 typedef __istream_type::__streambuf_type __streambuf_type;
284 typedef __istream_type::__ctype_type __ctype_type;
285 typedef basic_string<char> __string_type;
286 typedef __string_type::size_type __size_type;
287
288 __size_type __extracted = 0;
289 ios_base::iostate __err = ios_base::goodbit;
290 __istream_type::sentry __cerb(__in, false);
291 if (__cerb)
292 {
293 __try
294 {
295 __str.erase();
296 const streamsize __w = __in.width();
297 const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
298 : __str.max_size();
299 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
300 const __int_type __eof = __traits_type::eof();
301 __streambuf_type* __sb = __in.rdbuf();
302 __int_type __c = __sb->sgetc();
303
304 while (__extracted < __n
305 && !__traits_type::eq_int_type(__c, __eof)
306 && !__ct.is(ctype_base::space,
307 __traits_type::to_char_type(__c)))
308 {
309 streamsize __size = std::min(streamsize(__sb->egptr()
310 - __sb->gptr()),
311 streamsize(__n - __extracted));
312 if (__size > 1)
313 {
314 __size = (__ct.scan_is(ctype_base::space,
315 __sb->gptr() + 1,
316 __sb->gptr() + __size)
317 - __sb->gptr());
318 __str.append(__sb->gptr(), __size);
319 __sb->gbump(__size);
320 __extracted += __size;
321 __c = __sb->sgetc();
322 }
323 else
324 {
325 __str += __traits_type::to_char_type(__c);
326 ++__extracted;
327 __c = __sb->snextc();
328 }
329 }
330
331 if (__traits_type::eq_int_type(__c, __eof))
332 __err |= ios_base::eofbit;
333 __in.width(0);
334 }
335 __catch(__cxxabiv1::__forced_unwind&)
336 {
337 __in._M_setstate(ios_base::badbit);
338 __throw_exception_again;
339 }
340 __catch(...)
341 {
342 // _GLIBCXX_RESOLVE_LIB_DEFECTS
343 // 91. Description of operator>> and getline() for string<>
344 // might cause endless loop
345 __in._M_setstate(ios_base::badbit);
346 }
347 }
348 if (!__extracted)
349 __err |= ios_base::failbit;
350 if (__err)
351 __in.setstate(__err);
352 return __in;
353 }
354
355 template<>
356 basic_istream<char>&
357 getline(basic_istream<char>& __in, basic_string<char>& __str,
358 char __delim)
359 {
360 typedef basic_istream<char> __istream_type;
361 typedef __istream_type::int_type __int_type;
362 typedef __istream_type::char_type __char_type;
363 typedef __istream_type::traits_type __traits_type;
364 typedef __istream_type::__streambuf_type __streambuf_type;
365 typedef __istream_type::__ctype_type __ctype_type;
366 typedef basic_string<char> __string_type;
367 typedef __string_type::size_type __size_type;
368
369 __size_type __extracted = 0;
370 const __size_type __n = __str.max_size();
371 ios_base::iostate __err = ios_base::goodbit;
372 __istream_type::sentry __cerb(__in, true);
373 if (__cerb)
374 {
375 __try
376 {
377 __str.erase();
378 const __int_type __idelim = __traits_type::to_int_type(__delim);
379 const __int_type __eof = __traits_type::eof();
380 __streambuf_type* __sb = __in.rdbuf();
381 __int_type __c = __sb->sgetc();
382
383 while (__extracted < __n
384 && !__traits_type::eq_int_type(__c, __eof)
385 && !__traits_type::eq_int_type(__c, __idelim))
386 {
387 streamsize __size = std::min(streamsize(__sb->egptr()
388 - __sb->gptr()),
389 streamsize(__n - __extracted));
390 if (__size > 1)
391 {
392 const __char_type* __p = __traits_type::find(__sb->gptr(),
393 __size,
394 __delim);
395 if (__p)
396 __size = __p - __sb->gptr();
397 __str.append(__sb->gptr(), __size);
398 __sb->gbump(__size);
399 __extracted += __size;
400 __c = __sb->sgetc();
401 }
402 else
403 {
404 __str += __traits_type::to_char_type(__c);
405 ++__extracted;
406 __c = __sb->snextc();
407 }
408 }
409
410 if (__traits_type::eq_int_type(__c, __eof))
411 __err |= ios_base::eofbit;
412 else if (__traits_type::eq_int_type(__c, __idelim))
413 {
414 ++__extracted;
415 __sb->sbumpc();
416 }
417 else
418 __err |= ios_base::failbit;
419 }
420 __catch(__cxxabiv1::__forced_unwind&)
421 {
422 __in._M_setstate(ios_base::badbit);
423 __throw_exception_again;
424 }
425 __catch(...)
426 {
427 // _GLIBCXX_RESOLVE_LIB_DEFECTS
428 // 91. Description of operator>> and getline() for string<>
429 // might cause endless loop
430 __in._M_setstate(ios_base::badbit);
431 }
432 }
433 if (!__extracted)
434 __err |= ios_base::failbit;
435 if (__err)
436 __in.setstate(__err);
437 return __in;
438 }
439
440 #ifdef _GLIBCXX_USE_WCHAR_T
441 template<>
442 basic_istream<wchar_t>&
443 basic_istream<wchar_t>::
444 getline(char_type* __s, streamsize __n, char_type __delim)
445 {
446 _M_gcount = 0;
447 ios_base::iostate __err = ios_base::goodbit;
448 sentry __cerb(*this, true);
449 if (__cerb)
450 {
451 __try
452 {
453 const int_type __idelim = traits_type::to_int_type(__delim);
454 const int_type __eof = traits_type::eof();
455 __streambuf_type* __sb = this->rdbuf();
456 int_type __c = __sb->sgetc();
457
458 while (_M_gcount + 1 < __n
459 && !traits_type::eq_int_type(__c, __eof)
460 && !traits_type::eq_int_type(__c, __idelim))
461 {
462 streamsize __size = std::min(streamsize(__sb->egptr()
463 - __sb->gptr()),
464 streamsize(__n - _M_gcount
465 - 1));
466 if (__size > 1)
467 {
468 const char_type* __p = traits_type::find(__sb->gptr(),
469 __size,
470 __delim);
471 if (__p)
472 __size = __p - __sb->gptr();
473 traits_type::copy(__s, __sb->gptr(), __size);
474 __s += __size;
475 __sb->gbump(__size);
476 _M_gcount += __size;
477 __c = __sb->sgetc();
478 }
479 else
480 {
481 *__s++ = traits_type::to_char_type(__c);
482 ++_M_gcount;
483 __c = __sb->snextc();
484 }
485 }
486
487 if (traits_type::eq_int_type(__c, __eof))
488 __err |= ios_base::eofbit;
489 else if (traits_type::eq_int_type(__c, __idelim))
490 {
491 ++_M_gcount;
492 __sb->sbumpc();
493 }
494 else
495 __err |= ios_base::failbit;
496 }
497 __catch(__cxxabiv1::__forced_unwind&)
498 {
499 this->_M_setstate(ios_base::badbit);
500 __throw_exception_again;
501 }
502 __catch(...)
503 { this->_M_setstate(ios_base::badbit); }
504 }
505 // _GLIBCXX_RESOLVE_LIB_DEFECTS
506 // 243. get and getline when sentry reports failure.
507 if (__n > 0)
508 *__s = char_type();
509 if (!_M_gcount)
510 __err |= ios_base::failbit;
511 if (__err)
512 this->setstate(__err);
513 return *this;
514 }
515
516 template<>
517 basic_istream<wchar_t>&
518 basic_istream<wchar_t>::
519 ignore(streamsize __n, int_type __delim)
520 {
521 if (traits_type::eq_int_type(__delim, traits_type::eof()))
522 return ignore(__n);
523
524 _M_gcount = 0;
525 sentry __cerb(*this, true);
526 if (__n > 0 && __cerb)
527 {
528 ios_base::iostate __err = ios_base::goodbit;
529 __try
530 {
531 const char_type __cdelim = traits_type::to_char_type(__delim);
532 const int_type __eof = traits_type::eof();
533 __streambuf_type* __sb = this->rdbuf();
534 int_type __c = __sb->sgetc();
535
536 bool __large_ignore = false;
537 while (true)
538 {
539 while (_M_gcount < __n
540 && !traits_type::eq_int_type(__c, __eof)
541 && !traits_type::eq_int_type(__c, __delim))
542 {
543 streamsize __size = std::min(streamsize(__sb->egptr()
544 - __sb->gptr()),
545 streamsize(__n - _M_gcount));
546 if (__size > 1)
547 {
548 const char_type* __p = traits_type::find(__sb->gptr(),
549 __size,
550 __cdelim);
551 if (__p)
552 __size = __p - __sb->gptr();
553 __sb->gbump(__size);
554 _M_gcount += __size;
555 __c = __sb->sgetc();
556 }
557 else
558 {
559 ++_M_gcount;
560 __c = __sb->snextc();
561 }
562 }
563 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
564 && !traits_type::eq_int_type(__c, __eof)
565 && !traits_type::eq_int_type(__c, __delim))
566 {
567 _M_gcount =
568 __gnu_cxx::__numeric_traits<streamsize>::__min;
569 __large_ignore = true;
570 }
571 else
572 break;
573 }
574
575 if (__large_ignore)
576 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
577
578 if (traits_type::eq_int_type(__c, __eof))
579 __err |= ios_base::eofbit;
580 else if (traits_type::eq_int_type(__c, __delim))
581 {
582 if (_M_gcount
583 < __gnu_cxx::__numeric_traits<streamsize>::__max)
584 ++_M_gcount;
585 __sb->sbumpc();
586 }
587 }
588 __catch(__cxxabiv1::__forced_unwind&)
589 {
590 this->_M_setstate(ios_base::badbit);
591 __throw_exception_again;
592 }
593 __catch(...)
594 { this->_M_setstate(ios_base::badbit); }
595 if (__err)
596 this->setstate(__err);
597 }
598 return *this;
599 }
600
601 template<>
602 basic_istream<wchar_t>&
603 getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
604 wchar_t __delim)
605 {
606 typedef basic_istream<wchar_t> __istream_type;
607 typedef __istream_type::int_type __int_type;
608 typedef __istream_type::char_type __char_type;
609 typedef __istream_type::traits_type __traits_type;
610 typedef __istream_type::__streambuf_type __streambuf_type;
611 typedef __istream_type::__ctype_type __ctype_type;
612 typedef basic_string<wchar_t> __string_type;
613 typedef __string_type::size_type __size_type;
614
615 __size_type __extracted = 0;
616 const __size_type __n = __str.max_size();
617 ios_base::iostate __err = ios_base::goodbit;
618 __istream_type::sentry __cerb(__in, true);
619 if (__cerb)
620 {
621 __try
622 {
623 __str.erase();
624 const __int_type __idelim = __traits_type::to_int_type(__delim);
625 const __int_type __eof = __traits_type::eof();
626 __streambuf_type* __sb = __in.rdbuf();
627 __int_type __c = __sb->sgetc();
628
629 while (__extracted < __n
630 && !__traits_type::eq_int_type(__c, __eof)
631 && !__traits_type::eq_int_type(__c, __idelim))
632 {
633 streamsize __size = std::min(streamsize(__sb->egptr()
634 - __sb->gptr()),
635 streamsize(__n - __extracted));
636 if (__size > 1)
637 {
638 const __char_type* __p = __traits_type::find(__sb->gptr(),
639 __size,
640 __delim);
641 if (__p)
642 __size = __p - __sb->gptr();
643 __str.append(__sb->gptr(), __size);
644 __sb->gbump(__size);
645 __extracted += __size;
646 __c = __sb->sgetc();
647 }
648 else
649 {
650 __str += __traits_type::to_char_type(__c);
651 ++__extracted;
652 __c = __sb->snextc();
653 }
654 }
655
656 if (__traits_type::eq_int_type(__c, __eof))
657 __err |= ios_base::eofbit;
658 else if (__traits_type::eq_int_type(__c, __idelim))
659 {
660 ++__extracted;
661 __sb->sbumpc();
662 }
663 else
664 __err |= ios_base::failbit;
665 }
666 __catch(__cxxabiv1::__forced_unwind&)
667 {
668 __in._M_setstate(ios_base::badbit);
669 __throw_exception_again;
670 }
671 __catch(...)
672 {
673 // _GLIBCXX_RESOLVE_LIB_DEFECTS
674 // 91. Description of operator>> and getline() for string<>
675 // might cause endless loop
676 __in._M_setstate(ios_base::badbit);
677 }
678 }
679 if (!__extracted)
680 __err |= ios_base::failbit;
681 if (__err)
682 __in.setstate(__err);
683 return __in;
684 }
685 #endif
686
687 _GLIBCXX_END_NAMESPACE
GCC graphite test results