OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [libstdc++-v3/] [include/] [bits/] [istream.tcc] - Blame information for rev 17

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 17 jlechner 
// istream classes -*- C++ -*-
2 
 
3 
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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 2, 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 
// You should have received a copy of the GNU General Public License along
18 
// with this library; see the file COPYING.  If not, write to the Free
19 
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 
// USA.
21 
 
22 
// As a special exception, you may use this file as part of a free software
23 
// library without restriction.  Specifically, if other files instantiate
24 
// templates or use macros or inline functions from this file, or you compile
25 
// this file and link it with other files to produce an executable, this
26 
// file does not by itself cause the resulting executable to be covered by
27 
// the GNU General Public License.  This exception does not however
28 
// invalidate any other reasons why the executable file might be covered by
29 
// the GNU General Public License.
30 
 
31 
/** @file istream.tcc
32 
 *  This is an internal header file, included by other library headers.
33 
 *  You should not attempt to use it directly.
34 
 */
35 
 
36 
//
37 
// ISO C++ 14882: 27.6.1  Input streams
38 
//
39 
 
40 
#ifndef _ISTREAM_TCC
41 
#define _ISTREAM_TCC 1
42 
 
43 
#pragma GCC system_header
44 
 
45 
#include
46 
#include  // For flush()
47 
 
48 
namespace std
49 
{
50 
  template
51 
    basic_istream<_CharT, _Traits>::sentry::
52 
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
53 
    {
54 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
55 
      if (__in.good())
56 
        {
57 
          if (__in.tie())
58 
            __in.tie()->flush();
59 
          if (!__noskip && (__in.flags() & ios_base::skipws))
60 
            {
61 
              const __int_type __eof = traits_type::eof();
62 
              __streambuf_type* __sb = __in.rdbuf();
63 
              __int_type __c = __sb->sgetc();
64 
 
65 
              const __ctype_type& __ct = __check_facet(__in._M_ctype);
66 
              while (!traits_type::eq_int_type(__c, __eof)
67 
                     && __ct.is(ctype_base::space,
68 
                                traits_type::to_char_type(__c)))
69 
                __c = __sb->snextc();
70 
 
71 
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
72 
              // 195. Should basic_istream::sentry's constructor ever
73 
              // set eofbit?
74 
              if (traits_type::eq_int_type(__c, __eof))
75 
                __err |= ios_base::eofbit;
76 
            }
77 
        }
78 
 
79 
      if (__in.good() && __err == ios_base::goodbit)
80 
        _M_ok = true;
81 
      else
82 
        {
83 
          __err |= ios_base::failbit;
84 
          __in.setstate(__err);
85 
        }
86 
    }
87 
 
88 
  template
89 
    basic_istream<_CharT, _Traits>&
90 
    basic_istream<_CharT, _Traits>::
91 
    operator>>(__istream_type& (*__pf)(__istream_type&))
92 
    { return __pf(*this); }
93 
 
94 
  template
95 
    basic_istream<_CharT, _Traits>&
96 
    basic_istream<_CharT, _Traits>::
97 
    operator>>(__ios_type& (*__pf)(__ios_type&))
98 
    {
99 
      __pf(*this);
100 
      return *this;
101 
    }
102 
 
103 
  template
104 
    basic_istream<_CharT, _Traits>&
105 
    basic_istream<_CharT, _Traits>::
106 
    operator>>(ios_base& (*__pf)(ios_base&))
107 
    {
108 
      __pf(*this);
109 
      return *this;
110 
    }
111 
 
112 
  template
113 
    basic_istream<_CharT, _Traits>&
114 
    basic_istream<_CharT, _Traits>::
115 
    operator>>(bool& __n)
116 
    {
117 
      sentry __cerb(*this, false);
118 
      if (__cerb)
119 
        {
120 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
121 
          try
122 
            {
123 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
124 
              __ng.get(*this, 0, *this, __err, __n);
125 
            }
126 
          catch(...)
127 
            { this->_M_setstate(ios_base::badbit); }
128 
          if (__err)
129 
            this->setstate(__err);
130 
        }
131 
      return *this;
132 
    }
133 
 
134 
  template
135 
    basic_istream<_CharT, _Traits>&
136 
    basic_istream<_CharT, _Traits>::
137 
    operator>>(short& __n)
138 
    {
139 
      sentry __cerb(*this, false);
140 
      if (__cerb)
141 
        {
142 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
143 
          try
144 
            {
145 
              long __l;
146 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
147 
              __ng.get(*this, 0, *this, __err, __l);
148 
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
149 
              // 118. basic_istream uses nonexistent num_get member functions.
150 
              if (!(__err & ios_base::failbit)
151 
                  && (numeric_limits::min() <= __l
152 
                      && __l <= numeric_limits::max()))
153 
                __n = __l;
154 
              else
155 
                __err |= ios_base::failbit;
156 
            }
157 
          catch(...)
158 
            { this->_M_setstate(ios_base::badbit); }
159 
          if (__err)
160 
            this->setstate(__err);
161 
        }
162 
      return *this;
163 
    }
164 
 
165 
  template
166 
    basic_istream<_CharT, _Traits>&
167 
    basic_istream<_CharT, _Traits>::
168 
    operator>>(unsigned short& __n)
169 
    {
170 
      sentry __cerb(*this, false);
171 
      if (__cerb)
172 
        {
173 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
174 
          try
175 
            {
176 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
177 
              __ng.get(*this, 0, *this, __err, __n);
178 
            }
179 
          catch(...)
180 
            { this->_M_setstate(ios_base::badbit); }
181 
          if (__err)
182 
            this->setstate(__err);
183 
        }
184 
      return *this;
185 
    }
186 
 
187 
  template
188 
    basic_istream<_CharT, _Traits>&
189 
    basic_istream<_CharT, _Traits>::
190 
    operator>>(int& __n)
191 
    {
192 
      sentry __cerb(*this, false);
193 
      if (__cerb)
194 
        {
195 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
196 
          try
197 
            {
198 
              long __l;
199 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
200 
              __ng.get(*this, 0, *this, __err, __l);
201 
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
202 
              // 118. basic_istream uses nonexistent num_get member functions.
203 
              if (!(__err & ios_base::failbit)
204 
                  && (numeric_limits::min() <= __l
205 
                      && __l <= numeric_limits::max()))
206 
                __n = __l;
207 
              else
208 
                __err |= ios_base::failbit;
209 
            }
210 
          catch(...)
211 
            { this->_M_setstate(ios_base::badbit); }
212 
          if (__err)
213 
            this->setstate(__err);
214 
        }
215 
      return *this;
216 
    }
217 
 
218 
  template
219 
    basic_istream<_CharT, _Traits>&
220 
    basic_istream<_CharT, _Traits>::
221 
    operator>>(unsigned int& __n)
222 
    {
223 
      sentry __cerb(*this, false);
224 
      if (__cerb)
225 
        {
226 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
227 
          try
228 
            {
229 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
230 
              __ng.get(*this, 0, *this, __err, __n);
231 
            }
232 
          catch(...)
233 
            { this->_M_setstate(ios_base::badbit); }
234 
          if (__err)
235 
            this->setstate(__err);
236 
        }
237 
      return *this;
238 
    }
239 
 
240 
  template
241 
    basic_istream<_CharT, _Traits>&
242 
    basic_istream<_CharT, _Traits>::
243 
    operator>>(long& __n)
244 
    {
245 
      sentry __cerb(*this, false);
246 
      if (__cerb)
247 
        {
248 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
249 
          try
250 
            {
251 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
252 
              __ng.get(*this, 0, *this, __err, __n);
253 
            }
254 
          catch(...)
255 
            { this->_M_setstate(ios_base::badbit); }
256 
          if (__err)
257 
            this->setstate(__err);
258 
        }
259 
      return *this;
260 
    }
261 
 
262 
  template
263 
    basic_istream<_CharT, _Traits>&
264 
    basic_istream<_CharT, _Traits>::
265 
    operator>>(unsigned long& __n)
266 
    {
267 
      sentry __cerb(*this, false);
268 
      if (__cerb)
269 
        {
270 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
271 
          try
272 
            {
273 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
274 
              __ng.get(*this, 0, *this, __err, __n);
275 
            }
276 
          catch(...)
277 
            { this->_M_setstate(ios_base::badbit); }
278 
          if (__err)
279 
            this->setstate(__err);
280 
        }
281 
      return *this;
282 
    }
283 
 
284 
#ifdef _GLIBCXX_USE_LONG_LONG
285 
  template
286 
    basic_istream<_CharT, _Traits>&
287 
    basic_istream<_CharT, _Traits>::
288 
    operator>>(long long& __n)
289 
    {
290 
      sentry __cerb(*this, false);
291 
      if (__cerb)
292 
        {
293 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
294 
          try
295 
            {
296 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
297 
              __ng.get(*this, 0, *this, __err, __n);
298 
            }
299 
          catch(...)
300 
            { this->_M_setstate(ios_base::badbit); }
301 
          if (__err)
302 
            this->setstate(__err);
303 
        }
304 
      return *this;
305 
    }
306 
 
307 
  template
308 
    basic_istream<_CharT, _Traits>&
309 
    basic_istream<_CharT, _Traits>::
310 
    operator>>(unsigned long long& __n)
311 
    {
312 
      sentry __cerb(*this, false);
313 
      if (__cerb)
314 
        {
315 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
316 
          try
317 
            {
318 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
319 
              __ng.get(*this, 0, *this, __err, __n);
320 
            }
321 
          catch(...)
322 
            { this->_M_setstate(ios_base::badbit); }
323 
          if (__err)
324 
            this->setstate(__err);
325 
        }
326 
      return *this;
327 
    }
328 
#endif
329 
 
330 
  template
331 
    basic_istream<_CharT, _Traits>&
332 
    basic_istream<_CharT, _Traits>::
333 
    operator>>(float& __n)
334 
    {
335 
      sentry __cerb(*this, false);
336 
      if (__cerb)
337 
        {
338 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
339 
          try
340 
            {
341 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
342 
              __ng.get(*this, 0, *this, __err, __n);
343 
            }
344 
          catch(...)
345 
            { this->_M_setstate(ios_base::badbit); }
346 
          if (__err)
347 
            this->setstate(__err);
348 
        }
349 
      return *this;
350 
    }
351 
 
352 
  template
353 
    basic_istream<_CharT, _Traits>&
354 
    basic_istream<_CharT, _Traits>::
355 
    operator>>(double& __n)
356 
    {
357 
      sentry __cerb(*this, false);
358 
      if (__cerb)
359 
        {
360 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
361 
          try
362 
            {
363 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
364 
              __ng.get(*this, 0, *this, __err, __n);
365 
            }
366 
          catch(...)
367 
            { this->_M_setstate(ios_base::badbit); }
368 
          if (__err)
369 
            this->setstate(__err);
370 
        }
371 
      return *this;
372 
    }
373 
 
374 
  template
375 
    basic_istream<_CharT, _Traits>&
376 
    basic_istream<_CharT, _Traits>::
377 
    operator>>(long double& __n)
378 
    {
379 
      sentry __cerb(*this, false);
380 
      if (__cerb)
381 
        {
382 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
383 
          try
384 
            {
385 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
386 
              __ng.get(*this, 0, *this, __err, __n);
387 
            }
388 
          catch(...)
389 
            { this->_M_setstate(ios_base::badbit); }
390 
          if (__err)
391 
            this->setstate(__err);
392 
        }
393 
      return *this;
394 
    }
395 
 
396 
  template
397 
    basic_istream<_CharT, _Traits>&
398 
    basic_istream<_CharT, _Traits>::
399 
    operator>>(void*& __n)
400 
    {
401 
      sentry __cerb(*this, false);
402 
      if (__cerb)
403 
        {
404 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
405 
          try
406 
            {
407 
              const __num_get_type& __ng = __check_facet(this->_M_num_get);
408 
              __ng.get(*this, 0, *this, __err, __n);
409 
            }
410 
          catch(...)
411 
            { this->_M_setstate(ios_base::badbit); }
412 
          if (__err)
413 
            this->setstate(__err);
414 
        }
415 
      return *this;
416 
    }
417 
 
418 
  template
419 
    basic_istream<_CharT, _Traits>&
420 
    basic_istream<_CharT, _Traits>::
421 
    operator>>(__streambuf_type* __sbout)
422 
    {
423 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
424 
      sentry __cerb(*this, false);
425 
      if (__cerb && __sbout)
426 
        {
427 
          try
428 
            {
429 
              if (!__copy_streambufs(this->rdbuf(), __sbout))
430 
                __err |= ios_base::failbit;
431 
            }
432 
          catch(...)
433 
            { this->_M_setstate(ios_base::failbit); }
434 
        }
435 
      else if (!__sbout)
436 
        __err |= ios_base::failbit;
437 
      if (__err)
438 
        this->setstate(__err);
439 
      return *this;
440 
    }
441 
 
442 
  template
443 
    typename basic_istream<_CharT, _Traits>::int_type
444 
    basic_istream<_CharT, _Traits>::
445 
    get(void)
446 
    {
447 
      const int_type __eof = traits_type::eof();
448 
      int_type __c = __eof;
449 
      _M_gcount = 0;
450 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
451 
      sentry __cerb(*this, true);
452 
      if (__cerb)
453 
        {
454 
          try
455 
            {
456 
              __c = this->rdbuf()->sbumpc();
457 
              // 27.6.1.1 paragraph 3
458 
              if (!traits_type::eq_int_type(__c, __eof))
459 
                _M_gcount = 1;
460 
              else
461 
                __err |= ios_base::eofbit;
462 
            }
463 
          catch(...)
464 
            { this->_M_setstate(ios_base::badbit); }
465 
        }
466 
      if (!_M_gcount)
467 
        __err |= ios_base::failbit;
468 
      if (__err)
469 
        this->setstate(__err);
470 
      return __c;
471 
    }
472 
 
473 
  template
474 
    basic_istream<_CharT, _Traits>&
475 
    basic_istream<_CharT, _Traits>::
476 
    get(char_type& __c)
477 
    {
478 
      _M_gcount = 0;
479 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
480 
      sentry __cerb(*this, true);
481 
      if (__cerb)
482 
        {
483 
          try
484 
            {
485 
              const int_type __cb = this->rdbuf()->sbumpc();
486 
              // 27.6.1.1 paragraph 3
487 
              if (!traits_type::eq_int_type(__cb, traits_type::eof()))
488 
                {
489 
                  _M_gcount = 1;
490 
                  __c = traits_type::to_char_type(__cb);
491 
                }
492 
              else
493 
                __err |= ios_base::eofbit;
494 
            }
495 
          catch(...)
496 
            { this->_M_setstate(ios_base::badbit); }
497 
        }
498 
      if (!_M_gcount)
499 
        __err |= ios_base::failbit;
500 
      if (__err)
501 
        this->setstate(__err);
502 
      return *this;
503 
    }
504 
 
505 
  template
506 
    basic_istream<_CharT, _Traits>&
507 
    basic_istream<_CharT, _Traits>::
508 
    get(char_type* __s, streamsize __n, char_type __delim)
509 
    {
510 
      _M_gcount = 0;
511 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
512 
      sentry __cerb(*this, true);
513 
      if (__cerb)
514 
        {
515 
          try
516 
            {
517 
              const int_type __idelim = traits_type::to_int_type(__delim);
518 
              const int_type __eof = traits_type::eof();
519 
              __streambuf_type* __sb = this->rdbuf();
520 
              int_type __c = __sb->sgetc();
521 
 
522 
              while (_M_gcount + 1 < __n
523 
                     && !traits_type::eq_int_type(__c, __eof)
524 
                     && !traits_type::eq_int_type(__c, __idelim))
525 
                {
526 
                  *__s++ = traits_type::to_char_type(__c);
527 
                  ++_M_gcount;
528 
                  __c = __sb->snextc();
529 
                }
530 
              if (traits_type::eq_int_type(__c, __eof))
531 
                __err |= ios_base::eofbit;
532 
            }
533 
          catch(...)
534 
            { this->_M_setstate(ios_base::badbit); }
535 
        }
536 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
537 
      // 243. get and getline when sentry reports failure.
538 
      if (__n > 0)
539 
        *__s = char_type();
540 
      if (!_M_gcount)
541 
        __err |= ios_base::failbit;
542 
      if (__err)
543 
        this->setstate(__err);
544 
      return *this;
545 
    }
546 
 
547 
  template
548 
    basic_istream<_CharT, _Traits>&
549 
    basic_istream<_CharT, _Traits>::
550 
    get(__streambuf_type& __sb, char_type __delim)
551 
    {
552 
      _M_gcount = 0;
553 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
554 
      sentry __cerb(*this, true);
555 
      if (__cerb)
556 
        {
557 
          try
558 
            {
559 
              const int_type __idelim = traits_type::to_int_type(__delim);
560 
              const int_type __eof = traits_type::eof();
561 
              __streambuf_type* __this_sb = this->rdbuf();
562 
              int_type __c = __this_sb->sgetc();
563 
              char_type __c2 = traits_type::to_char_type(__c);
564 
 
565 
              while (!traits_type::eq_int_type(__c, __eof)
566 
                     && !traits_type::eq_int_type(__c, __idelim)
567 
                     && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
568 
                {
569 
                  ++_M_gcount;
570 
                  __c = __this_sb->snextc();
571 
                  __c2 = traits_type::to_char_type(__c);
572 
                }
573 
              if (traits_type::eq_int_type(__c, __eof))
574 
                __err |= ios_base::eofbit;
575 
            }
576 
          catch(...)
577 
            { this->_M_setstate(ios_base::badbit); }
578 
        }
579 
      if (!_M_gcount)
580 
        __err |= ios_base::failbit;
581 
      if (__err)
582 
        this->setstate(__err);
583 
      return *this;
584 
    }
585 
 
586 
  template
587 
    basic_istream<_CharT, _Traits>&
588 
    basic_istream<_CharT, _Traits>::
589 
    getline(char_type* __s, streamsize __n, char_type __delim)
590 
    {
591 
      _M_gcount = 0;
592 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
593 
      sentry __cerb(*this, true);
594 
      if (__cerb)
595 
        {
596 
          try
597 
            {
598 
              const int_type __idelim = traits_type::to_int_type(__delim);
599 
              const int_type __eof = traits_type::eof();
600 
              __streambuf_type* __sb = this->rdbuf();
601 
              int_type __c = __sb->sgetc();
602 
 
603 
              while (_M_gcount + 1 < __n
604 
                     && !traits_type::eq_int_type(__c, __eof)
605 
                     && !traits_type::eq_int_type(__c, __idelim))
606 
                {
607 
                  *__s++ = traits_type::to_char_type(__c);
608 
                  __c = __sb->snextc();
609 
                  ++_M_gcount;
610 
                }
611 
              if (traits_type::eq_int_type(__c, __eof))
612 
                __err |= ios_base::eofbit;
613 
              else
614 
                {
615 
                  if (traits_type::eq_int_type(__c, __idelim))
616 
                    {
617 
                      __sb->sbumpc();
618 
                      ++_M_gcount;
619 
                    }
620 
                  else
621 
                    __err |= ios_base::failbit;
622 
                }
623 
            }
624 
          catch(...)
625 
            { this->_M_setstate(ios_base::badbit); }
626 
        }
627 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
628 
      // 243. get and getline when sentry reports failure.
629 
      if (__n > 0)
630 
        *__s = char_type();
631 
      if (!_M_gcount)
632 
        __err |= ios_base::failbit;
633 
      if (__err)
634 
        this->setstate(__err);
635 
      return *this;
636 
    }
637 
 
638 
  // We provide three overloads, since the first two are much simpler
639 
  // than the general case. Also, the latter two can thus adopt the
640 
  // same "batchy" strategy used by getline above.
641 
  template
642 
    basic_istream<_CharT, _Traits>&
643 
    basic_istream<_CharT, _Traits>::
644 
    ignore(void)
645 
    {
646 
      _M_gcount = 0;
647 
      sentry __cerb(*this, true);
648 
      if (__cerb)
649 
        {
650 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
651 
          try
652 
            {
653 
              const int_type __eof = traits_type::eof();
654 
              __streambuf_type* __sb = this->rdbuf();
655 
 
656 
              if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
657 
                __err |= ios_base::eofbit;
658 
              else
659 
                _M_gcount = 1;
660 
            }
661 
          catch(...)
662 
            { this->_M_setstate(ios_base::badbit); }
663 
          if (__err)
664 
            this->setstate(__err);
665 
        }
666 
      return *this;
667 
    }
668 
 
669 
  template
670 
    basic_istream<_CharT, _Traits>&
671 
    basic_istream<_CharT, _Traits>::
672 
    ignore(streamsize __n)
673 
    {
674 
      _M_gcount = 0;
675 
      sentry __cerb(*this, true);
676 
      if (__cerb && __n > 0)
677 
        {
678 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
679 
          try
680 
            {
681 
              const int_type __eof = traits_type::eof();
682 
              __streambuf_type* __sb = this->rdbuf();
683 
              int_type __c = __sb->sgetc();
684 
 
685 
              // N.B. On LFS-enabled platforms streamsize is still 32 bits
686 
              // wide: if we want to implement the standard mandated behavior
687 
              // for n == max() (see 27.6.1.3/24) we are at risk of signed
688 
              // integer overflow: thus these contortions. Also note that,
689 
              // by definition, when more than 2G chars are actually ignored,
690 
              // _M_gcount (the return value of gcount, that is) cannot be
691 
              // really correct, being unavoidably too small.
692 
              bool __large_ignore = false;
693 
              while (true)
694 
                {
695 
                  while (_M_gcount < __n
696 
                         && !traits_type::eq_int_type(__c, __eof))
697 
                    {
698 
                      ++_M_gcount;
699 
                      __c = __sb->snextc();
700 
                    }
701 
                  if (__n == numeric_limits::max()
702 
                      && !traits_type::eq_int_type(__c, __eof))
703 
                    {
704 
                      _M_gcount = numeric_limits::min();
705 
                      __large_ignore = true;
706 
                    }
707 
                  else
708 
                    break;
709 
                }
710 
 
711 
              if (__large_ignore)
712 
                _M_gcount = numeric_limits::max();
713 
 
714 
              if (traits_type::eq_int_type(__c, __eof))
715 
                __err |= ios_base::eofbit;
716 
            }
717 
          catch(...)
718 
            { this->_M_setstate(ios_base::badbit); }
719 
          if (__err)
720 
            this->setstate(__err);
721 
        }
722 
      return *this;
723 
    }
724 
 
725 
  template
726 
    basic_istream<_CharT, _Traits>&
727 
    basic_istream<_CharT, _Traits>::
728 
    ignore(streamsize __n, int_type __delim)
729 
    {
730 
      _M_gcount = 0;
731 
      sentry __cerb(*this, true);
732 
      if (__cerb && __n > 0)
733 
        {
734 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
735 
          try
736 
            {
737 
              const int_type __eof = traits_type::eof();
738 
              __streambuf_type* __sb = this->rdbuf();
739 
              int_type __c = __sb->sgetc();
740 
 
741 
              // See comment above.
742 
              bool __large_ignore = false;
743 
              while (true)
744 
                {
745 
                  while (_M_gcount < __n
746 
                         && !traits_type::eq_int_type(__c, __eof)
747 
                         && !traits_type::eq_int_type(__c, __delim))
748 
                    {
749 
                      ++_M_gcount;
750 
                      __c = __sb->snextc();
751 
                    }
752 
                  if (__n == numeric_limits::max()
753 
                      && !traits_type::eq_int_type(__c, __eof)
754 
                      && !traits_type::eq_int_type(__c, __delim))
755 
                    {
756 
                      _M_gcount = numeric_limits::min();
757 
                      __large_ignore = true;
758 
                    }
759 
                  else
760 
                    break;
761 
                }
762 
 
763 
              if (__large_ignore)
764 
                _M_gcount = numeric_limits::max();
765 
 
766 
              if (traits_type::eq_int_type(__c, __eof))
767 
                __err |= ios_base::eofbit;
768 
              else if (traits_type::eq_int_type(__c, __delim))
769 
                {
770 
                  if (_M_gcount < numeric_limits::max())
771 
                    ++_M_gcount;
772 
                  __sb->sbumpc();
773 
                }
774 
            }
775 
          catch(...)
776 
            { this->_M_setstate(ios_base::badbit); }
777 
          if (__err)
778 
            this->setstate(__err);
779 
        }
780 
      return *this;
781 
    }
782 
 
783 
  template
784 
    typename basic_istream<_CharT, _Traits>::int_type
785 
    basic_istream<_CharT, _Traits>::
786 
    peek(void)
787 
    {
788 
      int_type __c = traits_type::eof();
789 
      _M_gcount = 0;
790 
      sentry __cerb(*this, true);
791 
      if (__cerb)
792 
        {
793 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
794 
          try
795 
            {
796 
              __c = this->rdbuf()->sgetc();
797 
              if (traits_type::eq_int_type(__c, traits_type::eof()))
798 
                __err |= ios_base::eofbit;
799 
            }
800 
          catch(...)
801 
            { this->_M_setstate(ios_base::badbit); }
802 
          if (__err)
803 
            this->setstate(__err);
804 
        }
805 
      return __c;
806 
    }
807 
 
808 
  template
809 
    basic_istream<_CharT, _Traits>&
810 
    basic_istream<_CharT, _Traits>::
811 
    read(char_type* __s, streamsize __n)
812 
    {
813 
      _M_gcount = 0;
814 
      sentry __cerb(*this, true);
815 
      if (__cerb)
816 
        {
817 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
818 
          try
819 
            {
820 
              _M_gcount = this->rdbuf()->sgetn(__s, __n);
821 
              if (_M_gcount != __n)
822 
                __err |= (ios_base::eofbit | ios_base::failbit);
823 
            }
824 
          catch(...)
825 
            { this->_M_setstate(ios_base::badbit); }
826 
          if (__err)
827 
            this->setstate(__err);
828 
        }
829 
      return *this;
830 
    }
831 
 
832 
  template
833 
    streamsize
834 
    basic_istream<_CharT, _Traits>::
835 
    readsome(char_type* __s, streamsize __n)
836 
    {
837 
      _M_gcount = 0;
838 
      sentry __cerb(*this, true);
839 
      if (__cerb)
840 
        {
841 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
842 
          try
843 
            {
844 
              // Cannot compare int_type with streamsize generically.
845 
              const streamsize __num = this->rdbuf()->in_avail();
846 
              if (__num > 0)
847 
                _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
848 
              else if (__num == -1)
849 
                __err |= ios_base::eofbit;
850 
            }
851 
          catch(...)
852 
            { this->_M_setstate(ios_base::badbit); }
853 
          if (__err)
854 
            this->setstate(__err);
855 
        }
856 
      return _M_gcount;
857 
    }
858 
 
859 
  template
860 
    basic_istream<_CharT, _Traits>&
861 
    basic_istream<_CharT, _Traits>::
862 
    putback(char_type __c)
863 
    {
864 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
865 
      // 60. What is a formatted input function?
866 
      _M_gcount = 0;
867 
      sentry __cerb(*this, true);
868 
      if (__cerb)
869 
        {
870 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
871 
          try
872 
            {
873 
              const int_type __eof = traits_type::eof();
874 
              __streambuf_type* __sb = this->rdbuf();
875 
              if (!__sb
876 
                  || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
877 
                __err |= ios_base::badbit;
878 
            }
879 
          catch(...)
880 
            { this->_M_setstate(ios_base::badbit); }
881 
          if (__err)
882 
            this->setstate(__err);
883 
        }
884 
      return *this;
885 
    }
886 
 
887 
  template
888 
    basic_istream<_CharT, _Traits>&
889 
    basic_istream<_CharT, _Traits>::
890 
    unget(void)
891 
    {
892 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
893 
      // 60. What is a formatted input function?
894 
      _M_gcount = 0;
895 
      sentry __cerb(*this, true);
896 
      if (__cerb)
897 
        {
898 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
899 
          try
900 
            {
901 
              const int_type __eof = traits_type::eof();
902 
              __streambuf_type* __sb = this->rdbuf();
903 
              if (!__sb
904 
                  || traits_type::eq_int_type(__sb->sungetc(), __eof))
905 
                __err |= ios_base::badbit;
906 
            }
907 
          catch(...)
908 
            { this->_M_setstate(ios_base::badbit); }
909 
          if (__err)
910 
            this->setstate(__err);
911 
        }
912 
      return *this;
913 
    }
914 
 
915 
  template
916 
    int
917 
    basic_istream<_CharT, _Traits>::
918 
    sync(void)
919 
    {
920 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
921 
      // DR60.  Do not change _M_gcount.
922 
      int __ret = -1;
923 
      sentry __cerb(*this, true);
924 
      if (__cerb)
925 
        {
926 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
927 
          try
928 
            {
929 
              __streambuf_type* __sb = this->rdbuf();
930 
              if (__sb)
931 
                {
932 
                  if (__sb->pubsync() == -1)
933 
                    __err |= ios_base::badbit;
934 
                  else
935 
                    __ret = 0;
936 
                }
937 
            }
938 
          catch(...)
939 
            { this->_M_setstate(ios_base::badbit); }
940 
          if (__err)
941 
            this->setstate(__err);
942 
        }
943 
      return __ret;
944 
    }
945 
 
946 
  template
947 
    typename basic_istream<_CharT, _Traits>::pos_type
948 
    basic_istream<_CharT, _Traits>::
949 
    tellg(void)
950 
    {
951 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
952 
      // DR60.  Do not change _M_gcount.
953 
      pos_type __ret = pos_type(-1);
954 
      try
955 
        {
956 
          if (!this->fail())
957 
            __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
958 
        }
959 
      catch(...)
960 
        { this->_M_setstate(ios_base::badbit); }
961 
      return __ret;
962 
    }
963 
 
964 
  template
965 
    basic_istream<_CharT, _Traits>&
966 
    basic_istream<_CharT, _Traits>::
967 
    seekg(pos_type __pos)
968 
    {
969 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
970 
      // DR60.  Do not change _M_gcount.
971 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
972 
      try
973 
        {
974 
          if (!this->fail())
975 
            {
976 
              // 136.  seekp, seekg setting wrong streams?
977 
              const pos_type __p = this->rdbuf()->pubseekpos(__pos,
978 
                                                             ios_base::in);
979 
 
980 
              // 129. Need error indication from seekp() and seekg()
981 
              if (__p == pos_type(off_type(-1)))
982 
                __err |= ios_base::failbit;
983 
            }
984 
        }
985 
      catch(...)
986 
        { this->_M_setstate(ios_base::badbit); }
987 
      if (__err)
988 
        this->setstate(__err);
989 
      return *this;
990 
    }
991 
 
992 
  template
993 
    basic_istream<_CharT, _Traits>&
994 
    basic_istream<_CharT, _Traits>::
995 
    seekg(off_type __off, ios_base::seekdir __dir)
996 
    {
997 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
998 
      // DR60.  Do not change _M_gcount.
999 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
1000 
      try
1001 
        {
1002 
          if (!this->fail())
1003 
            {
1004 
              // 136.  seekp, seekg setting wrong streams?
1005 
              const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
1006 
                                                             ios_base::in);
1007 
 
1008 
              // 129. Need error indication from seekp() and seekg()
1009 
              if (__p == pos_type(off_type(-1)))
1010 
                __err |= ios_base::failbit;
1011 
            }
1012 
        }
1013 
      catch(...)
1014 
        { this->_M_setstate(ios_base::badbit); }
1015 
      if (__err)
1016 
        this->setstate(__err);
1017 
      return *this;
1018 
    }
1019 
 
1020 
  // 27.6.1.2.3 Character extraction templates
1021 
  template
1022 
    basic_istream<_CharT, _Traits>&
1023 
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
1024 
    {
1025 
      typedef basic_istream<_CharT, _Traits>             __istream_type;
1026 
      typedef typename __istream_type::int_type         __int_type;
1027 
 
1028 
      typename __istream_type::sentry __cerb(__in, false);
1029 
      if (__cerb)
1030 
        {
1031 
          ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
1032 
          try
1033 
            {
1034 
              const __int_type __cb = __in.rdbuf()->sbumpc();
1035 
              if (!_Traits::eq_int_type(__cb, _Traits::eof()))
1036 
                __c = _Traits::to_char_type(__cb);
1037 
              else
1038 
                __err |= (ios_base::eofbit | ios_base::failbit);
1039 
            }
1040 
          catch(...)
1041 
            { __in._M_setstate(ios_base::badbit); }
1042 
          if (__err)
1043 
            __in.setstate(__err);
1044 
        }
1045 
      return __in;
1046 
    }
1047 
 
1048 
  template
1049 
    basic_istream<_CharT, _Traits>&
1050 
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
1051 
    {
1052 
      typedef basic_istream<_CharT, _Traits>             __istream_type;
1053 
      typedef typename __istream_type::__streambuf_type __streambuf_type;
1054 
      typedef typename _Traits::int_type                int_type;
1055 
      typedef _CharT                                    char_type;
1056 
      typedef ctype<_CharT>                             __ctype_type;
1057 
 
1058 
      streamsize __extracted = 0;
1059 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
1060 
      typename __istream_type::sentry __cerb(__in, false);
1061 
      if (__cerb)
1062 
        {
1063 
          try
1064 
            {
1065 
              // Figure out how many characters to extract.
1066 
              streamsize __num = __in.width();
1067 
              if (__num <= 0)
1068 
                __num = numeric_limits::max();
1069 
 
1070 
              const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1071 
 
1072 
              const int_type __eof = _Traits::eof();
1073 
              __streambuf_type* __sb = __in.rdbuf();
1074 
              int_type __c = __sb->sgetc();
1075 
 
1076 
              while (__extracted < __num - 1
1077 
                     && !_Traits::eq_int_type(__c, __eof)
1078 
                     && !__ct.is(ctype_base::space,
1079 
                                 _Traits::to_char_type(__c)))
1080 
                {
1081 
                  *__s++ = _Traits::to_char_type(__c);
1082 
                  ++__extracted;
1083 
                  __c = __sb->snextc();
1084 
                }
1085 
              if (_Traits::eq_int_type(__c, __eof))
1086 
                __err |= ios_base::eofbit;
1087 
 
1088 
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
1089 
              // 68.  Extractors for char* should store null at end
1090 
              *__s = char_type();
1091 
              __in.width(0);
1092 
            }
1093 
          catch(...)
1094 
            { __in._M_setstate(ios_base::badbit); }
1095 
        }
1096 
      if (!__extracted)
1097 
        __err |= ios_base::failbit;
1098 
      if (__err)
1099 
        __in.setstate(__err);
1100 
      return __in;
1101 
    }
1102 
 
1103 
  // 27.6.1.4 Standard basic_istream manipulators
1104 
  template
1105 
    basic_istream<_CharT,_Traits>&
1106 
    ws(basic_istream<_CharT,_Traits>& __in)
1107 
    {
1108 
      typedef basic_istream<_CharT, _Traits>             __istream_type;
1109 
      typedef typename __istream_type::__streambuf_type __streambuf_type;
1110 
      typedef typename __istream_type::__ctype_type     __ctype_type;
1111 
      typedef typename __istream_type::int_type         __int_type;
1112 
 
1113 
      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1114 
      const __int_type __eof = _Traits::eof();
1115 
      __streambuf_type* __sb = __in.rdbuf();
1116 
      __int_type __c = __sb->sgetc();
1117 
 
1118 
      while (!_Traits::eq_int_type(__c, __eof)
1119 
             && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1120 
        __c = __sb->snextc();
1121 
 
1122 
       if (_Traits::eq_int_type(__c, __eof))
1123 
         __in.setstate(ios_base::eofbit);
1124 
      return __in;
1125 
    }
1126 
 
1127 
  // 21.3.7.9 basic_string::getline and operators
1128 
  template
1129 
    basic_istream<_CharT, _Traits>&
1130 
    operator>>(basic_istream<_CharT, _Traits>& __in,
1131 
               basic_string<_CharT, _Traits, _Alloc>& __str)
1132 
    {
1133 
      typedef basic_istream<_CharT, _Traits>             __istream_type;
1134 
      typedef typename __istream_type::int_type         __int_type;
1135 
      typedef typename __istream_type::__streambuf_type __streambuf_type;
1136 
      typedef typename __istream_type::__ctype_type     __ctype_type;
1137 
      typedef basic_string<_CharT, _Traits, _Alloc>      __string_type;
1138 
      typedef typename __string_type::size_type         __size_type;
1139 
 
1140 
      __size_type __extracted = 0;
1141 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
1142 
      typename __istream_type::sentry __cerb(__in, false);
1143 
      if (__cerb)
1144 
        {
1145 
          try
1146 
            {
1147 
              // Avoid reallocation for common case.
1148 
              __str.erase();
1149 
              _CharT __buf[128];
1150 
              __size_type __len = 0;
1151 
              const streamsize __w = __in.width();
1152 
              const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
1153 
                                              : __str.max_size();
1154 
              const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
1155 
              const __int_type __eof = _Traits::eof();
1156 
              __streambuf_type* __sb = __in.rdbuf();
1157 
              __int_type __c = __sb->sgetc();
1158 
 
1159 
              while (__extracted < __n
1160 
                     && !_Traits::eq_int_type(__c, __eof)
1161 
                     && !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
1162 
                {
1163 
                  if (__len == sizeof(__buf) / sizeof(_CharT))
1164 
                    {
1165 
                      __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
1166 
                      __len = 0;
1167 
                    }
1168 
                  __buf[__len++] = _Traits::to_char_type(__c);
1169 
                  ++__extracted;
1170 
                  __c = __sb->snextc();
1171 
                }
1172 
              __str.append(__buf, __len);
1173 
 
1174 
              if (_Traits::eq_int_type(__c, __eof))
1175 
                __err |= ios_base::eofbit;
1176 
              __in.width(0);
1177 
            }
1178 
          catch(...)
1179 
            {
1180 
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
1181 
              // 91. Description of operator>> and getline() for string<>
1182 
              // might cause endless loop
1183 
              __in._M_setstate(ios_base::badbit);
1184 
            }
1185 
        }
1186 
      // 211.  operator>>(istream&, string&) doesn't set failbit
1187 
      if (!__extracted)
1188 
        __err |= ios_base::failbit;
1189 
      if (__err)
1190 
        __in.setstate(__err);
1191 
      return __in;
1192 
    }
1193 
 
1194 
  template
1195 
    basic_istream<_CharT, _Traits>&
1196 
    getline(basic_istream<_CharT, _Traits>& __in,
1197 
            basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
1198 
    {
1199 
      typedef basic_istream<_CharT, _Traits>             __istream_type;
1200 
      typedef typename __istream_type::int_type         __int_type;
1201 
      typedef typename __istream_type::__streambuf_type __streambuf_type;
1202 
      typedef typename __istream_type::__ctype_type     __ctype_type;
1203 
      typedef basic_string<_CharT, _Traits, _Alloc>      __string_type;
1204 
      typedef typename __string_type::size_type         __size_type;
1205 
 
1206 
      __size_type __extracted = 0;
1207 
      const __size_type __n = __str.max_size();
1208 
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
1209 
      typename __istream_type::sentry __cerb(__in, true);
1210 
      if (__cerb)
1211 
        {
1212 
          try
1213 
            {
1214 
              __str.erase();
1215 
              const __int_type __idelim = _Traits::to_int_type(__delim);
1216 
              const __int_type __eof = _Traits::eof();
1217 
              __streambuf_type* __sb = __in.rdbuf();
1218 
              __int_type __c = __sb->sgetc();
1219 
 
1220 
              while (__extracted < __n
1221 
                     && !_Traits::eq_int_type(__c, __eof)
1222 
                     && !_Traits::eq_int_type(__c, __idelim))
1223 
                {
1224 
                  __str += _Traits::to_char_type(__c);
1225 
                  ++__extracted;
1226 
                  __c = __sb->snextc();
1227 
                }
1228 
 
1229 
              if (_Traits::eq_int_type(__c, __eof))
1230 
                __err |= ios_base::eofbit;
1231 
              else if (_Traits::eq_int_type(__c, __idelim))
1232 
                {
1233 
                  ++__extracted;
1234 
                  __sb->sbumpc();
1235 
                }
1236 
              else
1237 
                __err |= ios_base::failbit;
1238 
            }
1239 
          catch(...)
1240 
            {
1241 
              // _GLIBCXX_RESOLVE_LIB_DEFECTS
1242 
              // 91. Description of operator>> and getline() for string<>
1243 
              // might cause endless loop
1244 
              __in._M_setstate(ios_base::badbit);
1245 
            }
1246 
        }
1247 
      if (!__extracted)
1248 
        __err |= ios_base::failbit;
1249 
      if (__err)
1250 
        __in.setstate(__err);
1251 
      return __in;
1252 
    }
1253 
 
1254 
  template
1255 
    inline basic_istream<_CharT,_Traits>&
1256 
    getline(basic_istream<_CharT, _Traits>& __in,
1257 
            basic_string<_CharT,_Traits,_Alloc>& __str)
1258 
    { return getline(__in, __str, __in.widen('\n')); }
1259 
 
1260 
  // Inhibit implicit instantiations for required instantiations,
1261 
  // which are defined via explicit instantiations elsewhere.
1262 
  // NB:  This syntax is a GNU extension.
1263 
#if _GLIBCXX_EXTERN_TEMPLATE
1264 
  extern template class basic_istream;
1265 
  extern template istream& ws(istream&);
1266 
  extern template istream& operator>>(istream&, char&);
1267 
  extern template istream& operator>>(istream&, char*);
1268 
  extern template istream& operator>>(istream&, unsigned char&);
1269 
  extern template istream& operator>>(istream&, signed char&);
1270 
  extern template istream& operator>>(istream&, unsigned char*);
1271 
  extern template istream& operator>>(istream&, signed char*);
1272 
 
1273 
  extern template class basic_iostream;
1274 
 
1275 
#ifdef _GLIBCXX_USE_WCHAR_T
1276 
  extern template class basic_istream;
1277 
  extern template wistream& ws(wistream&);
1278 
  extern template wistream& operator>>(wistream&, wchar_t&);
1279 
  extern template wistream& operator>>(wistream&, wchar_t*);
1280 
 
1281 
  extern template class basic_iostream;
1282 
#endif
1283 
#endif
1284 
} // namespace std
1285 
 
1286 
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.