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