?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/xtensa/lib1funcs.asm (__umodsi3, __modsi3): Rearrange so that
[official-gcc.git] / libstdc++-v3 / src / istream.cc
blob0f24340e031b6e3c225f231dff2cbfd194eb9caf
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 _GLIBCXX_BEGIN_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 == __gnu_cxx::__numeric_traits<streamsize>::__max
156 && !traits_type::eq_int_type(__c, __eof)
157 && !traits_type::eq_int_type(__c, __delim))
158 {
159 _M_gcount =
160 __gnu_cxx::__numeric_traits<streamsize>::__min;
161 __large_ignore = true;
162 }
163 else
164 break;
165 }
166
167 if (__large_ignore)
168 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
169
170 if (traits_type::eq_int_type(__c, __eof))
171 __err |= ios_base::eofbit;
172 else if (traits_type::eq_int_type(__c, __delim))
173 {
174 if (_M_gcount
175 < __gnu_cxx::__numeric_traits<streamsize>::__max)
176 ++_M_gcount;
177 __sb->sbumpc();
178 }
179 }
180 catch(...)
181 { this->_M_setstate(ios_base::badbit); }
182 if (__err)
183 this->setstate(__err);
184 }
185 return *this;
186 }
187
188 template<>
189 basic_istream<char>&
190 operator>>(basic_istream<char>& __in, char* __s)
191 {
192 typedef basic_istream<char> __istream_type;
193 typedef __istream_type::int_type __int_type;
194 typedef __istream_type::char_type __char_type;
195 typedef __istream_type::traits_type __traits_type;
196 typedef __istream_type::__streambuf_type __streambuf_type;
197 typedef __istream_type::__ctype_type __ctype_type;
198
199 streamsize __extracted = 0;
200 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
201 __istream_type::sentry __cerb(__in, false);
202 if (__cerb)
203 {
204 try
205 {
206 // Figure out how many characters to extract.
207 streamsize __num = __in.width();
208 if (__num <= 0)
209 __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
210
211 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
212
213 const __int_type __eof = __traits_type::eof();
214 __streambuf_type* __sb = __in.rdbuf();
215 __int_type __c = __sb->sgetc();
216
217 while (__extracted < __num - 1
218 && !__traits_type::eq_int_type(__c, __eof)
219 && !__ct.is(ctype_base::space,
220 __traits_type::to_char_type(__c)))
221 {
222 streamsize __size = std::min(streamsize(__sb->egptr()
223 - __sb->gptr()),
224 streamsize(__num - __extracted
225 - 1));
226 if (__size > 1)
227 {
228 __size = (__ct.scan_is(ctype_base::space,
229 __sb->gptr() + 1,
230 __sb->gptr() + __size)
231 - __sb->gptr());
232 __traits_type::copy(__s, __sb->gptr(), __size);
233 __s += __size;
234 __sb->gbump(__size);
235 __extracted += __size;
236 __c = __sb->sgetc();
237 }
238 else
239 {
240 *__s++ = __traits_type::to_char_type(__c);
241 ++__extracted;
242 __c = __sb->snextc();
243 }
244 }
245
246 if (__traits_type::eq_int_type(__c, __eof))
247 __err |= ios_base::eofbit;
248
249 // _GLIBCXX_RESOLVE_LIB_DEFECTS
250 // 68. Extractors for char* should store null at end
251 *__s = __char_type();
252 __in.width(0);
253 }
254 catch(...)
255 { __in._M_setstate(ios_base::badbit); }
256 }
257 if (!__extracted)
258 __err |= ios_base::failbit;
259 if (__err)
260 __in.setstate(__err);
261 return __in;
262 }
263
264 template<>
265 basic_istream<char>&
266 operator>>(basic_istream<char>& __in, basic_string<char>& __str)
267 {
268 typedef basic_istream<char> __istream_type;
269 typedef __istream_type::int_type __int_type;
270 typedef __istream_type::char_type __char_type;
271 typedef __istream_type::traits_type __traits_type;
272 typedef __istream_type::__streambuf_type __streambuf_type;
273 typedef __istream_type::__ctype_type __ctype_type;
274 typedef basic_string<char> __string_type;
275 typedef __string_type::size_type __size_type;
276
277 __size_type __extracted = 0;
278 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
279 __istream_type::sentry __cerb(__in, false);
280 if (__cerb)
281 {
282 try
283 {
284 __str.erase();
285 const streamsize __w = __in.width();
286 const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
287 : __str.max_size();
288 const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
289 const __int_type __eof = __traits_type::eof();
290 __streambuf_type* __sb = __in.rdbuf();
291 __int_type __c = __sb->sgetc();
292
293 while (__extracted < __n
294 && !__traits_type::eq_int_type(__c, __eof)
295 && !__ct.is(ctype_base::space,
296 __traits_type::to_char_type(__c)))
297 {
298 streamsize __size = std::min(streamsize(__sb->egptr()
299 - __sb->gptr()),
300 streamsize(__n - __extracted));
301 if (__size > 1)
302 {
303 __size = (__ct.scan_is(ctype_base::space,
304 __sb->gptr() + 1,
305 __sb->gptr() + __size)
306 - __sb->gptr());
307 __str.append(__sb->gptr(), __size);
308 __sb->gbump(__size);
309 __extracted += __size;
310 __c = __sb->sgetc();
311 }
312 else
313 {
314 __str += __traits_type::to_char_type(__c);
315 ++__extracted;
316 __c = __sb->snextc();
317 }
318 }
319
320 if (__traits_type::eq_int_type(__c, __eof))
321 __err |= ios_base::eofbit;
322 __in.width(0);
323 }
324 catch(...)
325 {
326 // _GLIBCXX_RESOLVE_LIB_DEFECTS
327 // 91. Description of operator>> and getline() for string<>
328 // might cause endless loop
329 __in._M_setstate(ios_base::badbit);
330 }
331 }
332 if (!__extracted)
333 __err |= ios_base::failbit;
334 if (__err)
335 __in.setstate(__err);
336 return __in;
337 }
338
339 template<>
340 basic_istream<char>&
341 getline(basic_istream<char>& __in, basic_string<char>& __str,
342 char __delim)
343 {
344 typedef basic_istream<char> __istream_type;
345 typedef __istream_type::int_type __int_type;
346 typedef __istream_type::char_type __char_type;
347 typedef __istream_type::traits_type __traits_type;
348 typedef __istream_type::__streambuf_type __streambuf_type;
349 typedef __istream_type::__ctype_type __ctype_type;
350 typedef basic_string<char> __string_type;
351 typedef __string_type::size_type __size_type;
352
353 __size_type __extracted = 0;
354 const __size_type __n = __str.max_size();
355 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
356 __istream_type::sentry __cerb(__in, true);
357 if (__cerb)
358 {
359 try
360 {
361 __str.erase();
362 const __int_type __idelim = __traits_type::to_int_type(__delim);
363 const __int_type __eof = __traits_type::eof();
364 __streambuf_type* __sb = __in.rdbuf();
365 __int_type __c = __sb->sgetc();
366
367 while (__extracted < __n
368 && !__traits_type::eq_int_type(__c, __eof)
369 && !__traits_type::eq_int_type(__c, __idelim))
370 {
371 streamsize __size = std::min(streamsize(__sb->egptr()
372 - __sb->gptr()),
373 streamsize(__n - __extracted));
374 if (__size > 1)
375 {
376 const __char_type* __p = __traits_type::find(__sb->gptr(),
377 __size,
378 __delim);
379 if (__p)
380 __size = __p - __sb->gptr();
381 __str.append(__sb->gptr(), __size);
382 __sb->gbump(__size);
383 __extracted += __size;
384 __c = __sb->sgetc();
385 }
386 else
387 {
388 __str += __traits_type::to_char_type(__c);
389 ++__extracted;
390 __c = __sb->snextc();
391 }
392 }
393
394 if (__traits_type::eq_int_type(__c, __eof))
395 __err |= ios_base::eofbit;
396 else if (__traits_type::eq_int_type(__c, __idelim))
397 {
398 ++__extracted;
399 __sb->sbumpc();
400 }
401 else
402 __err |= ios_base::failbit;
403 }
404 catch(...)
405 {
406 // _GLIBCXX_RESOLVE_LIB_DEFECTS
407 // 91. Description of operator>> and getline() for string<>
408 // might cause endless loop
409 __in._M_setstate(ios_base::badbit);
410 }
411 }
412 if (!__extracted)
413 __err |= ios_base::failbit;
414 if (__err)
415 __in.setstate(__err);
416 return __in;
417 }
418
419 #ifdef _GLIBCXX_USE_WCHAR_T
420 template<>
421 basic_istream<wchar_t>&
422 basic_istream<wchar_t>::
423 getline(char_type* __s, streamsize __n, char_type __delim)
424 {
425 _M_gcount = 0;
426 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
427 sentry __cerb(*this, true);
428 if (__cerb)
429 {
430 try
431 {
432 const int_type __idelim = traits_type::to_int_type(__delim);
433 const int_type __eof = traits_type::eof();
434 __streambuf_type* __sb = this->rdbuf();
435 int_type __c = __sb->sgetc();
436
437 while (_M_gcount + 1 < __n
438 && !traits_type::eq_int_type(__c, __eof)
439 && !traits_type::eq_int_type(__c, __idelim))
440 {
441 streamsize __size = std::min(streamsize(__sb->egptr()
442 - __sb->gptr()),
443 streamsize(__n - _M_gcount
444 - 1));
445 if (__size > 1)
446 {
447 const char_type* __p = traits_type::find(__sb->gptr(),
448 __size,
449 __delim);
450 if (__p)
451 __size = __p - __sb->gptr();
452 traits_type::copy(__s, __sb->gptr(), __size);
453 __s += __size;
454 __sb->gbump(__size);
455 _M_gcount += __size;
456 __c = __sb->sgetc();
457 }
458 else
459 {
460 *__s++ = traits_type::to_char_type(__c);
461 ++_M_gcount;
462 __c = __sb->snextc();
463 }
464 }
465
466 if (traits_type::eq_int_type(__c, __eof))
467 __err |= ios_base::eofbit;
468 else if (traits_type::eq_int_type(__c, __idelim))
469 {
470 ++_M_gcount;
471 __sb->sbumpc();
472 }
473 else
474 __err |= ios_base::failbit;
475 }
476 catch(...)
477 { this->_M_setstate(ios_base::badbit); }
478 }
479 // _GLIBCXX_RESOLVE_LIB_DEFECTS
480 // 243. get and getline when sentry reports failure.
481 if (__n > 0)
482 *__s = char_type();
483 if (!_M_gcount)
484 __err |= ios_base::failbit;
485 if (__err)
486 this->setstate(__err);
487 return *this;
488 }
489
490 template<>
491 basic_istream<wchar_t>&
492 basic_istream<wchar_t>::
493 ignore(streamsize __n, int_type __delim)
494 {
495 if (traits_type::eq_int_type(__delim, traits_type::eof()))
496 return ignore(__n);
497
498 _M_gcount = 0;
499 sentry __cerb(*this, true);
500 if (__cerb && __n > 0)
501 {
502 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
503 try
504 {
505 const char_type __cdelim = traits_type::to_char_type(__delim);
506 const int_type __eof = traits_type::eof();
507 __streambuf_type* __sb = this->rdbuf();
508 int_type __c = __sb->sgetc();
509
510 bool __large_ignore = false;
511 while (true)
512 {
513 while (_M_gcount < __n
514 && !traits_type::eq_int_type(__c, __eof)
515 && !traits_type::eq_int_type(__c, __delim))
516 {
517 streamsize __size = std::min(streamsize(__sb->egptr()
518 - __sb->gptr()),
519 streamsize(__n - _M_gcount));
520 if (__size > 1)
521 {
522 const char_type* __p = traits_type::find(__sb->gptr(),
523 __size,
524 __cdelim);
525 if (__p)
526 __size = __p - __sb->gptr();
527 __sb->gbump(__size);
528 _M_gcount += __size;
529 __c = __sb->sgetc();
530 }
531 else
532 {
533 ++_M_gcount;
534 __c = __sb->snextc();
535 }
536 }
537 if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
538 && !traits_type::eq_int_type(__c, __eof)
539 && !traits_type::eq_int_type(__c, __delim))
540 {
541 _M_gcount =
542 __gnu_cxx::__numeric_traits<streamsize>::__min;
543 __large_ignore = true;
544 }
545 else
546 break;
547 }
548
549 if (__large_ignore)
550 _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
551
552 if (traits_type::eq_int_type(__c, __eof))
553 __err |= ios_base::eofbit;
554 else if (traits_type::eq_int_type(__c, __delim))
555 {
556 if (_M_gcount
557 < __gnu_cxx::__numeric_traits<streamsize>::__max)
558 ++_M_gcount;
559 __sb->sbumpc();
560 }
561 }
562 catch(...)
563 { this->_M_setstate(ios_base::badbit); }
564 if (__err)
565 this->setstate(__err);
566 }
567 return *this;
568 }
569
570 template<>
571 basic_istream<wchar_t>&
572 getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
573 wchar_t __delim)
574 {
575 typedef basic_istream<wchar_t> __istream_type;
576 typedef __istream_type::int_type __int_type;
577 typedef __istream_type::char_type __char_type;
578 typedef __istream_type::traits_type __traits_type;
579 typedef __istream_type::__streambuf_type __streambuf_type;
580 typedef __istream_type::__ctype_type __ctype_type;
581 typedef basic_string<wchar_t> __string_type;
582 typedef __string_type::size_type __size_type;
583
584 __size_type __extracted = 0;
585 const __size_type __n = __str.max_size();
586 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
587 __istream_type::sentry __cerb(__in, true);
588 if (__cerb)
589 {
590 try
591 {
592 __str.erase();
593 const __int_type __idelim = __traits_type::to_int_type(__delim);
594 const __int_type __eof = __traits_type::eof();
595 __streambuf_type* __sb = __in.rdbuf();
596 __int_type __c = __sb->sgetc();
597
598 while (__extracted < __n
599 && !__traits_type::eq_int_type(__c, __eof)
600 && !__traits_type::eq_int_type(__c, __idelim))
601 {
602 streamsize __size = std::min(streamsize(__sb->egptr()
603 - __sb->gptr()),
604 streamsize(__n - __extracted));
605 if (__size > 1)
606 {
607 const __char_type* __p = __traits_type::find(__sb->gptr(),
608 __size,
609 __delim);
610 if (__p)
611 __size = __p - __sb->gptr();
612 __str.append(__sb->gptr(), __size);
613 __sb->gbump(__size);
614 __extracted += __size;
615 __c = __sb->sgetc();
616 }
617 else
618 {
619 __str += __traits_type::to_char_type(__c);
620 ++__extracted;
621 __c = __sb->snextc();
622 }
623 }
624
625 if (__traits_type::eq_int_type(__c, __eof))
626 __err |= ios_base::eofbit;
627 else if (__traits_type::eq_int_type(__c, __idelim))
628 {
629 ++__extracted;
630 __sb->sbumpc();
631 }
632 else
633 __err |= ios_base::failbit;
634 }
635 catch(...)
636 {
637 // _GLIBCXX_RESOLVE_LIB_DEFECTS
638 // 91. Description of operator>> and getline() for string<>
639 // might cause endless loop
640 __in._M_setstate(ios_base::badbit);
641 }
642 }
643 if (!__extracted)
644 __err |= ios_base::failbit;
645 if (__err)
646 __in.setstate(__err);
647 return __in;
648 }
649 #endif
650
651 _GLIBCXX_END_NAMESPACE
Mirror of the offical gcc git repository hosted at gcc.gnu.org