?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* Makefile.in (WERROR_FLAGS): Renamed from WERROR.
[official-gcc.git] / libstdc++-v3 / src / istream.cc
blob39de7538f0d9eb2cec96e64e180057be44b95c2c
1 // Input streams -*- C++ -*-
2
3 // Copyright (C) 2004 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
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)
112 {
113 if (__n == 1)
114 return ignore();
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 int_type __eof = traits_type::eof();
124 __streambuf_type* __sb = this->rdbuf();
125 int_type __c = __sb->sgetc();
126
127 const bool __bound = __n != numeric_limits<streamsize>::max();
128 if (__bound)
129 --__n;
130 while (_M_gcount <= __n
131 && !traits_type::eq_int_type(__c, __eof))
132 {
133 streamsize __size = __sb->egptr() - __sb->gptr();
134 if (__bound)
135 __size = std::min(__size, streamsize(__n - _M_gcount + 1));
136
137 if (__size > 1)
138 {
139 __sb->gbump(__size);
140 _M_gcount += __size;
141 __c = __sb->sgetc();
142 }
143 else
144 {
145 ++_M_gcount;
146 __c = __sb->snextc();
147 }
148 }
149 if (traits_type::eq_int_type(__c, __eof))
150 __err |= ios_base::eofbit;
151 }
152 catch(...)
153 { this->_M_setstate(ios_base::badbit); }
154 if (__err)
155 this->setstate(__err);
156 }
157 return *this;
158 }
159
160 template<>
161 basic_istream<char>&
162 basic_istream<char>::
163 ignore(streamsize __n, int_type __delim)
164 {
165 if (traits_type::eq_int_type(__delim, traits_type::eof()))
166 return ignore(__n);
167
168 _M_gcount = 0;
169 sentry __cerb(*this, true);
170 if (__cerb && __n > 0)
171 {
172 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
173 try
174 {
175 const char_type __cdelim = traits_type::to_char_type(__delim);
176 const int_type __eof = traits_type::eof();
177 __streambuf_type* __sb = this->rdbuf();
178 int_type __c = __sb->sgetc();
179
180 const bool __bound = __n != numeric_limits<streamsize>::max();
181 if (__bound)
182 --__n;
183 while (_M_gcount <= __n
184 && !traits_type::eq_int_type(__c, __eof)
185 && !traits_type::eq_int_type(__c, __delim))
186 {
187 streamsize __size = __sb->egptr() - __sb->gptr();
188 if (__bound)
189 __size = std::min(__size, streamsize(__n - _M_gcount + 1));
190
191 if (__size > 1)
192 {
193 const char_type* __p = traits_type::find(__sb->gptr(),
194 __size,
195 __cdelim);
196 if (__p)
197 __size = __p - __sb->gptr();
198 __sb->gbump(__size);
199 _M_gcount += __size;
200 __c = __sb->sgetc();
201 }
202 else
203 {
204 ++_M_gcount;
205 __c = __sb->snextc();
206 }
207 }
208 if (traits_type::eq_int_type(__c, __eof))
209 __err |= ios_base::eofbit;
210 else if (traits_type::eq_int_type(__c, __delim))
211 {
212 ++_M_gcount;
213 __sb->sbumpc();
214 }
215 }
216 catch(...)
217 { this->_M_setstate(ios_base::badbit); }
218 if (__err)
219 this->setstate(__err);
220 }
221 return *this;
222 }
223
224 template<>
225 basic_istream<char>&
226 getline(basic_istream<char>& __in, basic_string<char>& __str,
227 char __delim)
228 {
229 typedef basic_istream<char> __istream_type;
230 typedef __istream_type::int_type __int_type;
231 typedef __istream_type::char_type __char_type;
232 typedef __istream_type::traits_type __traits_type;
233 typedef __istream_type::__streambuf_type __streambuf_type;
234 typedef __istream_type::__ctype_type __ctype_type;
235 typedef basic_string<char> __string_type;
236 typedef __string_type::size_type __size_type;
237
238 __size_type __extracted = 0;
239 const __size_type __n = __str.max_size();
240 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
241 __istream_type::sentry __cerb(__in, true);
242 if (__cerb)
243 {
244 try
245 {
246 __str.erase();
247 const __int_type __idelim = __traits_type::to_int_type(__delim);
248 const __int_type __eof = __traits_type::eof();
249 __streambuf_type* __sb = __in.rdbuf();
250 __int_type __c = __sb->sgetc();
251
252 while (__extracted < __n
253 && !__traits_type::eq_int_type(__c, __eof)
254 && !__traits_type::eq_int_type(__c, __idelim))
255 {
256 streamsize __size = std::min(streamsize(__sb->egptr()
257 - __sb->gptr()),
258 streamsize(__n - __extracted));
259 if (__size > 1)
260 {
261 const __char_type* __p = __traits_type::find(__sb->gptr(),
262 __size,
263 __delim);
264 if (__p)
265 __size = __p - __sb->gptr();
266 __str.append(__sb->gptr(), __size);
267 __sb->gbump(__size);
268 __extracted += __size;
269 __c = __sb->sgetc();
270 }
271 else
272 {
273 __str += __traits_type::to_char_type(__c);
274 ++__extracted;
275 __c = __sb->snextc();
276 }
277 }
278
279 if (__traits_type::eq_int_type(__c, __eof))
280 __err |= ios_base::eofbit;
281 else if (__traits_type::eq_int_type(__c, __idelim))
282 {
283 ++__extracted;
284 __sb->sbumpc();
285 }
286 else
287 __err |= ios_base::failbit;
288 }
289 catch(...)
290 {
291 // _GLIBCXX_RESOLVE_LIB_DEFECTS
292 // 91. Description of operator>> and getline() for string<>
293 // might cause endless loop
294 __in._M_setstate(ios_base::badbit);
295 }
296 }
297 if (!__extracted)
298 __err |= ios_base::failbit;
299 if (__err)
300 __in.setstate(__err);
301 return __in;
302 }
303
304 #ifdef _GLIBCXX_USE_WCHAR_T
305 template<>
306 basic_istream<wchar_t>&
307 basic_istream<wchar_t>::
308 getline(char_type* __s, streamsize __n, char_type __delim)
309 {
310 _M_gcount = 0;
311 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
312 sentry __cerb(*this, true);
313 if (__cerb)
314 {
315 try
316 {
317 const int_type __idelim = traits_type::to_int_type(__delim);
318 const int_type __eof = traits_type::eof();
319 __streambuf_type* __sb = this->rdbuf();
320 int_type __c = __sb->sgetc();
321
322 while (_M_gcount + 1 < __n
323 && !traits_type::eq_int_type(__c, __eof)
324 && !traits_type::eq_int_type(__c, __idelim))
325 {
326 streamsize __size = std::min(streamsize(__sb->egptr()
327 - __sb->gptr()),
328 streamsize(__n - _M_gcount
329 - 1));
330 if (__size > 1)
331 {
332 const char_type* __p = traits_type::find(__sb->gptr(),
333 __size,
334 __delim);
335 if (__p)
336 __size = __p - __sb->gptr();
337 traits_type::copy(__s, __sb->gptr(), __size);
338 __s += __size;
339 __sb->gbump(__size);
340 _M_gcount += __size;
341 __c = __sb->sgetc();
342 }
343 else
344 {
345 *__s++ = traits_type::to_char_type(__c);
346 ++_M_gcount;
347 __c = __sb->snextc();
348 }
349 }
350
351 if (traits_type::eq_int_type(__c, __eof))
352 __err |= ios_base::eofbit;
353 else if (traits_type::eq_int_type(__c, __idelim))
354 {
355 ++_M_gcount;
356 __sb->sbumpc();
357 }
358 else
359 __err |= ios_base::failbit;
360 }
361 catch(...)
362 { this->_M_setstate(ios_base::badbit); }
363 }
364 // _GLIBCXX_RESOLVE_LIB_DEFECTS
365 // 243. get and getline when sentry reports failure.
366 if (__n > 0)
367 *__s = char_type();
368 if (!_M_gcount)
369 __err |= ios_base::failbit;
370 if (__err)
371 this->setstate(__err);
372 return *this;
373 }
374
375 template<>
376 basic_istream<wchar_t>&
377 basic_istream<wchar_t>::
378 ignore(streamsize __n)
379 {
380 if (__n == 1)
381 return ignore();
382
383 _M_gcount = 0;
384 sentry __cerb(*this, true);
385 if (__cerb && __n > 0)
386 {
387 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
388 try
389 {
390 const int_type __eof = traits_type::eof();
391 __streambuf_type* __sb = this->rdbuf();
392 int_type __c = __sb->sgetc();
393
394 const bool __bound = __n != numeric_limits<streamsize>::max();
395 if (__bound)
396 --__n;
397 while (_M_gcount <= __n
398 && !traits_type::eq_int_type(__c, __eof))
399 {
400 streamsize __size = __sb->egptr() - __sb->gptr();
401 if (__bound)
402 __size = std::min(__size, streamsize(__n - _M_gcount + 1));
403
404 if (__size > 1)
405 {
406 __sb->gbump(__size);
407 _M_gcount += __size;
408 __c = __sb->sgetc();
409 }
410 else
411 {
412 ++_M_gcount;
413 __c = __sb->snextc();
414 }
415 }
416 if (traits_type::eq_int_type(__c, __eof))
417 __err |= ios_base::eofbit;
418 }
419 catch(...)
420 { this->_M_setstate(ios_base::badbit); }
421 if (__err)
422 this->setstate(__err);
423 }
424 return *this;
425 }
426
427 template<>
428 basic_istream<wchar_t>&
429 basic_istream<wchar_t>::
430 ignore(streamsize __n, int_type __delim)
431 {
432 if (traits_type::eq_int_type(__delim, traits_type::eof()))
433 return ignore(__n);
434
435 _M_gcount = 0;
436 sentry __cerb(*this, true);
437 if (__cerb && __n > 0)
438 {
439 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
440 try
441 {
442 const char_type __cdelim = traits_type::to_char_type(__delim);
443 const int_type __eof = traits_type::eof();
444 __streambuf_type* __sb = this->rdbuf();
445 int_type __c = __sb->sgetc();
446
447 const bool __bound = __n != numeric_limits<streamsize>::max();
448 if (__bound)
449 --__n;
450 while (_M_gcount <= __n
451 && !traits_type::eq_int_type(__c, __eof)
452 && !traits_type::eq_int_type(__c, __delim))
453 {
454 streamsize __size = __sb->egptr() - __sb->gptr();
455 if (__bound)
456 __size = std::min(__size, streamsize(__n - _M_gcount + 1));
457
458 if (__size > 1)
459 {
460 const char_type* __p = traits_type::find(__sb->gptr(),
461 __size,
462 __cdelim);
463 if (__p)
464 __size = __p - __sb->gptr();
465 __sb->gbump(__size);
466 _M_gcount += __size;
467 __c = __sb->sgetc();
468 }
469 else
470 {
471 ++_M_gcount;
472 __c = __sb->snextc();
473 }
474 }
475 if (traits_type::eq_int_type(__c, __eof))
476 __err |= ios_base::eofbit;
477 else if (traits_type::eq_int_type(__c, __delim))
478 {
479 ++_M_gcount;
480 __sb->sbumpc();
481 }
482 }
483 catch(...)
484 { this->_M_setstate(ios_base::badbit); }
485 if (__err)
486 this->setstate(__err);
487 }
488 return *this;
489 }
490
491 template<>
492 basic_istream<wchar_t>&
493 getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
494 wchar_t __delim)
495 {
496 typedef basic_istream<wchar_t> __istream_type;
497 typedef __istream_type::int_type __int_type;
498 typedef __istream_type::char_type __char_type;
499 typedef __istream_type::traits_type __traits_type;
500 typedef __istream_type::__streambuf_type __streambuf_type;
501 typedef __istream_type::__ctype_type __ctype_type;
502 typedef basic_string<wchar_t> __string_type;
503 typedef __string_type::size_type __size_type;
504
505 __size_type __extracted = 0;
506 const __size_type __n = __str.max_size();
507 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
508 __istream_type::sentry __cerb(__in, true);
509 if (__cerb)
510 {
511 try
512 {
513 __str.erase();
514 const __int_type __idelim = __traits_type::to_int_type(__delim);
515 const __int_type __eof = __traits_type::eof();
516 __streambuf_type* __sb = __in.rdbuf();
517 __int_type __c = __sb->sgetc();
518
519 while (__extracted < __n
520 && !__traits_type::eq_int_type(__c, __eof)
521 && !__traits_type::eq_int_type(__c, __idelim))
522 {
523 streamsize __size = std::min(streamsize(__sb->egptr()
524 - __sb->gptr()),
525 streamsize(__n - __extracted));
526 if (__size > 1)
527 {
528 const __char_type* __p = __traits_type::find(__sb->gptr(),
529 __size,
530 __delim);
531 if (__p)
532 __size = __p - __sb->gptr();
533 __str.append(__sb->gptr(), __size);
534 __sb->gbump(__size);
535 __extracted += __size;
536 __c = __sb->sgetc();
537 }
538 else
539 {
540 __str += __traits_type::to_char_type(__c);
541 ++__extracted;
542 __c = __sb->snextc();
543 }
544 }
545
546 if (__traits_type::eq_int_type(__c, __eof))
547 __err |= ios_base::eofbit;
548 else if (__traits_type::eq_int_type(__c, __idelim))
549 {
550 ++__extracted;
551 __sb->sbumpc();
552 }
553 else
554 __err |= ios_base::failbit;
555 }
556 catch(...)
557 {
558 // _GLIBCXX_RESOLVE_LIB_DEFECTS
559 // 91. Description of operator>> and getline() for string<>
560 // might cause endless loop
561 __in._M_setstate(ios_base::badbit);
562 }
563 }
564 if (!__extracted)
565 __err |= ios_base::failbit;
566 if (__err)
567 __in.setstate(__err);
568 return __in;
569 }
570 #endif
571 } // namespace std
Mirror of the offical gcc git repository hosted at gcc.gnu.org