_istream.c File Reference

#include <stl/_istream.h>
#include <stl/_limits.h>
#include <stl/_num_get.h>

Include dependency graph for _istream.c:

Go to the source code of this file.

Classes
struct	_Is_not_wspace< _Traits >
struct	_Is_wspace_null< _Traits >
struct	_Scan_for_wspace< _Traits >
struct	_Scan_wspace_null< _Traits >
struct	_Scan_for_not_wspace< _Traits >
struct	_Scan_for_char_val< _Traits >
struct	_Scan_for_int_val< _Traits >

Macros
#define	_STLP_ISTREAM_C
#define	__BIS_int_type__   _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::int_type
#define	__BIS_pos_type__   _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::pos_type
#define	__BIS_off_type__   _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::off_type

Functions
template<class _CharT , class _Traits >
bool _STLP_CALL	__pushback (basic_streambuf< _CharT, _Traits > *__buf, _CharT __c)
template<class _CharT , class _Traits , class _Number >
ios_base::iostate _STLP_CALL	__get_num (basic_istream< _CharT, _Traits > &__that, _Number &__val)
template<class _CharT , class _Traits , class _Is_Delim >
_STLP_MOVE_TO_PRIV_NAMESPACE streamsize _STLP_CALL	__read_unbuffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__buf, streamsize _Num, _CharT *__s, _Is_Delim __is_delim, bool __extract_delim, bool __append_null, bool __is_getline)
template<class _CharT , class _Traits , class _Is_Delim , class _Scan_Delim >
streamsize _STLP_CALL	__read_buffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__buf, streamsize _Num, _CharT *__s, _Is_Delim __is_delim, _Scan_Delim __scan_delim, bool __extract_delim, bool __append_null, bool __is_getline)
template<class _CharT , class _Traits , class _Is_Delim >
void _STLP_CALL	_M_ignore_unbuffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__buf, _Is_Delim __is_delim, bool __extract_delim, bool __set_failbit)
template<class _CharT , class _Traits , class _Is_Delim , class _Scan_Delim >
void _STLP_CALL	_M_ignore_buffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__buf, _Is_Delim __is_delim, _Scan_Delim __scan_delim, bool __extract_delim, bool __set_failbit)
template<class _CharT , class _Traits , class _Max_Chars , class _Is_Delim >
streamsize _STLP_CALL	_M_ignore_unbuffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__buf, streamsize _Num, _Max_Chars __max_chars, _Is_Delim __is_delim, bool __extract_delim, bool __set_failbit)
template<class _CharT , class _Traits , class _Max_Chars , class _Is_Delim , class _Scan_Delim >
streamsize _STLP_CALL	_M_ignore_buffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__buf, streamsize _Num, _Max_Chars __max_chars, _Is_Delim __is_delim, _Scan_Delim __scan_delim, bool __extract_delim, bool __set_failbit)
template<class _CharT , class _Traits , class _Is_Delim >
_STLP_MOVE_TO_PRIV_NAMESPACE streamsize _STLP_CALL	__copy_unbuffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__src, basic_streambuf< _CharT, _Traits > *__dest, _Is_Delim __is_delim, bool __extract_delim, bool __rethrow)
template<class _CharT , class _Traits , class _Is_Delim , class _Scan_Delim >
streamsize _STLP_CALL	__copy_buffered (basic_istream< _CharT, _Traits > *__that, basic_streambuf< _CharT, _Traits > *__src, basic_streambuf< _CharT, _Traits > *__dest, _Scan_Delim __scan_delim, _Is_Delim __is_delim, bool __extract_delim, bool __rethrow)

Macro Definition Documentation

__BIS_int_type__

#define __BIS_int_type__   _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::int_type

Definition at line 39 of file _istream.c.

__BIS_off_type__

#define __BIS_off_type__   _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::off_type

Definition at line 41 of file _istream.c.

__BIS_pos_type__

#define __BIS_pos_type__   _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::pos_type

Definition at line 40 of file _istream.c.

_STLP_ISTREAM_C

#define _STLP_ISTREAM_C

Definition at line 19 of file _istream.c.

Function Documentation

__copy_buffered()

template<class _CharT , class _Traits , class _Is_Delim , class _Scan_Delim >

streamsize _STLP_CALL __copy_buffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__src,
		basic_streambuf< _CharT, _Traits > *	__dest,
		_Scan_Delim	__scan_delim,
		_Is_Delim	__is_delim,
		bool	__extract_delim,
		bool	__rethrow
	)

Definition at line 1282 of file _istream.c.

                                                      {
  streamsize __extracted = 0;
  ios_base::iostate __status = 0;
  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
  //Borland compiler generates a warning if assignment because value is never used:
  int_type __c /*= _Traits::eof()*/;
  _CharT* __first = __src->_M_gptr();
  ptrdiff_t __avail = __src->_M_egptr() - __first;
  // fbp : introduced to move catch/try blocks out of the loop
  bool __do_handle_exceptions = false;
 
  _STLP_TRY {
    for (;;) {
      const _CharT* __last = __scan_delim(__first, __src->_M_egptr());
 
      // Try to copy the entire input buffer to the output buffer.
      streamsize __n = __dest->sputn(__first, __extract_delim && __last != __src->_M_egptr()
                                     ? (__last - __first) + 1
                                     : (__last - __first));
      __src->_M_gbump((int)__n);
      __extracted += __n;
 
      // from this on, catch() will call _M_handle_exceptions()
      __do_handle_exceptions = true;
 
      if (__n < __avail)          // We found the delimiter, or else failed to
        break;                    // copy some characters.
 
      __c = __src->sgetc();
 
      // Three possibilities: we succeeded in refilling the buffer, or
      // we got EOF, or the streambuf has switched to unbuffered mode.
      __first = __src->_M_gptr();
      __avail = __src->_M_egptr() - __first;
 
      if (__avail > 0)
        {}  // dwa 1/16/00 -- suppress a Metrowerks warning
      else if (__that->_S_eof(__c)) {
        __status |= ios_base::eofbit;
        break;
      }
      else {
        return __extracted + __copy_unbuffered(__that,  __src, __dest, __is_delim,
                                                __extract_delim, __rethrow);
      }
 
      __do_handle_exceptions = false;
    }
  }
 
  _STLP_CATCH_ALL {
    // See 27.6.1.2.3, paragraph 13.
    if (__rethrow && __do_handle_exceptions &&  __extracted == 0)
      __that->_M_handle_exception(ios_base::failbit);
  }
 
  if (__status)
    __that->setstate(__status);   // This might throw.
  return __extracted;
}

Referenced by basic_istream< _CharT, _Traits >::get(), and basic_istream< _CharT, _Traits >::operator>>().

__copy_unbuffered()

template<class _CharT , class _Traits , class _Is_Delim >

_STLP_MOVE_TO_PRIV_NAMESPACE streamsize _STLP_CALL __copy_unbuffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__src,
		basic_streambuf< _CharT, _Traits > *	__dest,
		_Is_Delim	__is_delim,
		bool	__extract_delim,
		bool	__rethrow
	)

Definition at line 1213 of file _istream.c.

                                                        {
  streamsize __extracted = 0;
  ios_base::iostate __status = 0;
  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
  int_type __c;
 
  _STLP_TRY {
    for (;;) {
      // Get a character. If there's an exception, catch and (maybe) rethrow it.
      __c = __src->sbumpc();
 
      // If we failed to get a character, then quit.
      if (__that->_S_eof(__c)) {
        __status |= ios_base::eofbit;
        break;
      }
      // If it's the delimiter, then quit.
      else if (__is_delim(_Traits::to_char_type(__c))) {
        if (!__extract_delim && !__pushback(__src, _Traits::to_char_type(__c)))
          __status |= ios_base::failbit;
        break;
      }
      else {
        // Try to put the character in the output streambuf.
        bool __failed = false;
        _STLP_TRY {
          if (!__that->_S_eof(__dest->sputc(_Traits::to_char_type(__c))))
            ++__extracted;
          else
            __failed = true;
        }
        _STLP_CATCH_ALL {
          __failed = true;
        }
 
        // If we failed to put the character in the output streambuf, then
        // try to push it back to the input streambuf.
        if (__failed && !__pushback(__src, _Traits::to_char_type(__c)))
          __status |= ios_base::failbit;
 
        // fbp : avoiding infinite loop in io-27-6-1-2-3.exp
        if (__failed)
          break;
      }
 
    } /* for (;;) */
 
  }
  // fbp : this try/catch moved here in reasonable assumption
  // __is_delim never throw (__pushback is guaranteed not to)
  _STLP_CATCH_ALL {
    // See 27.6.1.2.3, paragraph 13.
    if (__rethrow && __extracted == 0)
      __that->_M_handle_exception(ios_base::failbit);
  }
  __that->setstate(__status);
  return __extracted;
}

Referenced by __copy_buffered(), basic_istream< _CharT, _Traits >::get(), and basic_istream< _CharT, _Traits >::operator>>().

__get_num()

template<class _CharT , class _Traits , class _Number >

ios_base::iostate _STLP_CALL __get_num	(	basic_istream< _CharT, _Traits > &	__that,
		_Number &	__val
	)

Definition at line 186 of file _istream.c.

                                                                  {
  typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
  ios_base::iostate __err = 0;
  _Sentry __sentry( __that );     // Skip whitespace.
  if (__sentry) {
    typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > _Num_get;
    _STLP_TRY {
      // Do not remove additional parenthesis around use_facet instanciation, some compilers (VC6)
      // require it when building the library.
      (use_facet<_Num_get>(__that.getloc())).get(istreambuf_iterator<_CharT, _Traits>(__that.rdbuf()),
                                               0, __that, __err, __val);
    }
    _STLP_CATCH_ALL {
      __that._M_handle_exception(ios_base::badbit);
    }
    if (__err) __that.setstate(__err);
  }
  return __err;
}

Referenced by basic_istream< _CharT, _Traits >::operator>>().

__pushback()

template<class _CharT , class _Traits >

bool _STLP_CALL __pushback	(	basic_streambuf< _CharT, _Traits > *	__buf,
		_CharT	__c
	)

Definition at line 168 of file _istream.c.

                                                                {
  bool ret;
  _STLP_TRY {
    const typename _Traits::int_type __eof = _Traits::eof();
    ret = !_Traits::eq_int_type(__buf->sputbackc(__c), __eof);
  }
  _STLP_CATCH_ALL {
    ret = false;
  }
  return ret;
}

Referenced by __copy_unbuffered(), and __read_unbuffered().

__read_buffered()

template<class _CharT , class _Traits , class _Is_Delim , class _Scan_Delim >

streamsize _STLP_CALL __read_buffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__buf,
		streamsize	_Num,
		_CharT *	__s,
		_Is_Delim	__is_delim,
		_Scan_Delim	__scan_delim,
		bool	__extract_delim,
		bool	__append_null,
		bool	__is_getline
	)

Definition at line 635 of file _istream.c.

                                    {
  streamsize __n = 0;
  ios_base::iostate __status = 0;
  bool __done    = false;
 
  _STLP_TRY {
    while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
      const _CharT* __first = __buf->_M_gptr();
      const _CharT* __last  = __buf->_M_egptr();
      //casting numeric_limits<ptrdiff_t>::max to streamsize only works is ptrdiff_t is signed or streamsize representation
      //is larger than ptrdiff_t one.
      _STLP_STATIC_ASSERT((sizeof(streamsize) > sizeof(ptrdiff_t)) ||
                          ((sizeof(streamsize) == sizeof(ptrdiff_t)) && numeric_limits<ptrdiff_t>::is_signed))
      ptrdiff_t __request = __STATIC_CAST(ptrdiff_t, (min) (__STATIC_CAST(streamsize, (numeric_limits<ptrdiff_t>::max)()), _Num - __n));
 
      const _CharT* __p  = __scan_delim(__first, __last);
      ptrdiff_t __chunk = (min) (ptrdiff_t(__p - __first), __request);
      _Traits::copy(__s, __first, __chunk);
      __s += __chunk;
      __n += __chunk;
      __buf->_M_gbump((int)__chunk);
 
      // We terminated by finding delim.
      if (__p != __last && __p - __first <= __request) {
        if (__extract_delim) {
          __n += 1;
          __buf->_M_gbump(1);
        }
        __done = true;
      }
 
      // We terminated by reading all the characters we were asked for.
      else if (__n == _Num) {
 
        // Find out if we have reached eof.  This matters for getline.
        if (__is_getline) {
          if (__chunk == __last - __first) {
            if (__that->_S_eof(__buf->sgetc()))
              __status |= ios_base::eofbit;
          }
          else
            __status |= ios_base::failbit;
        }
        __done   = true;
      }
 
      // The buffer contained fewer than _Num - __n characters.  Either we're
      // at eof, or we should refill the buffer and try again.
      else {
        if (__that->_S_eof(__buf->sgetc())) {
          __status |= ios_base::eofbit;
          __done = true;
        }
      }
    } // Close the while loop.
  }
  _STLP_CATCH_ALL {
    __that->_M_handle_exception(ios_base::badbit);
    __done = true;
  }
 
  if (__done) {
    if (__append_null)
        *__s =  _STLP_DEFAULT_CONSTRUCTED(_CharT);
    if (__status != 0)
      __that->setstate(__status);   // This might throw.
    return __n;
  }
 
  // If execution has reached this point, then we have an empty buffer but
  // we have not reached eof.  What that means is that the streambuf has
  // decided to switch from buffered to unbuffered input.  We switch to
  // to __read_unbuffered.
 
  return __n + __read_unbuffered(__that,  __buf, _Num - __n, __s, __is_delim,
                                 __extract_delim,__append_null,__is_getline);
}

Referenced by basic_istream< _CharT, _Traits >::_M_formatted_get(), basic_istream< _CharT, _Traits >::get(), basic_istream< _CharT, _Traits >::getline(), basic_istream< _CharT, _Traits >::read(), and basic_istream< _CharT, _Traits >::readsome().

__read_unbuffered()

template<class _CharT , class _Traits , class _Is_Delim >

_STLP_MOVE_TO_PRIV_NAMESPACE streamsize _STLP_CALL __read_unbuffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__buf,
		streamsize	_Num,
		_CharT *	__s,
		_Is_Delim	__is_delim,
		bool	__extract_delim,
		bool	__append_null,
		bool	__is_getline
	)

Definition at line 579 of file _istream.c.

{
  streamsize __n = 0;
  ios_base::iostate __status = 0;
 
  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
  // The operations that can potentially throw are sbumpc, snextc, and sgetc.
  _STLP_TRY {
    for (;;) {
      if (__n == _Num) {
        if (__is_getline) // didn't find delimiter as one of the _Num chars
          __status |= ios_base::failbit;
        break;
      }
      int_type __c = __buf->sbumpc(); // sschwarz
 
      if (__that->_S_eof(__c)) {
        if (__n < _Num || __is_getline)
          __status |= ios_base::eofbit;
        break;
      } else if (__is_delim(_Traits::to_char_type(__c))) {
        if (__extract_delim) { // Extract and discard current character.
          ++__n;
        } else if ( !__pushback(__buf, _Traits::to_char_type(__c)) ) { // leave delimiter
          __status |= ios_base::failbit;
        }
        break;
      }
      // regular character
      *__s++ = _Traits::to_char_type(__c);
      ++__n;
    }
  }
  _STLP_CATCH_ALL {
    __that->_M_handle_exception(ios_base::badbit);
    *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT);
    return __n;
  }
 
  if (__append_null)
    *__s =  _STLP_DEFAULT_CONSTRUCTED(_CharT);
  if (__status)
    __that->setstate(__status);    // This might throw.
  return __n;
}

Referenced by __read_buffered(), basic_istream< _CharT, _Traits >::_M_formatted_get(), basic_istream< _CharT, _Traits >::get(), basic_istream< _CharT, _Traits >::getline(), basic_istream< _CharT, _Traits >::read(), and basic_istream< _CharT, _Traits >::readsome().

_M_ignore_buffered() [1/2]

template<class _CharT , class _Traits , class _Is_Delim , class _Scan_Delim >

void _STLP_CALL _M_ignore_buffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__buf,
		_Is_Delim	__is_delim,
		_Scan_Delim	__scan_delim,
		bool	__extract_delim,
		bool	__set_failbit
	)

Definition at line 928 of file _istream.c.

                                                             {
  bool __at_eof      = false;
  bool __found_delim = false;
 
  _STLP_TRY {
    while (__buf->_M_egptr() != __buf->_M_gptr() && !__at_eof && !__found_delim) {
      const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
      __buf->_M_gbump((int)(__p - __buf->_M_gptr()));
 
      if (__p != __buf->_M_egptr()) { // We found delim, so we're done.
        if (__extract_delim)
          __buf->_M_gbump(1);
        __found_delim = true;
      }
 
      else                         // No delim.  Try to refil the buffer.
        __at_eof = __that->_S_eof(__buf->sgetc());
    }                              // Close the while loop.
  }
  _STLP_CATCH_ALL {
    __that->_M_handle_exception(ios_base::badbit);
    return;
  }
 
  if (__at_eof) {
    __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
                                   : ios_base::eofbit);
    return;
  }
  if (__found_delim)
    return;
 
  // If execution has reached this point, then we have an empty buffer but
  // we have not reached eof.  What that means is that the streambuf has
  // decided to switch from a buffered to an unbuffered mode.  We switch
  // to _M_ignore_unbuffered.
  _M_ignore_unbuffered(__that,  __buf, __is_delim, __extract_delim, __set_failbit);
}

Referenced by basic_istream< _CharT, _Traits >::_M_skip_whitespace(), and basic_istream< _CharT, _Traits >::ignore().

_M_ignore_buffered() [2/2]

template<class _CharT , class _Traits , class _Max_Chars , class _Is_Delim , class _Scan_Delim >

streamsize _STLP_CALL _M_ignore_buffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__buf,
		streamsize	_Num,
		_Max_Chars	__max_chars,
		_Is_Delim	__is_delim,
		_Scan_Delim	__scan_delim,
		bool	__extract_delim,
		bool	__set_failbit
	)

Definition at line 1025 of file _istream.c.

                                                             {
  streamsize __n = 0;
  bool __at_eof = false;
  bool __done   = false;
 
  _STLP_TRY {
    while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) {
      ptrdiff_t __avail = __buf->_M_egptr() - __buf->_M_gptr();
      streamsize __m = __max_chars(_Num, __n);
 
      if (__avail >= __m) {       // We have more characters than we need.
        const _CharT* __last = __buf->_M_gptr() + __STATIC_CAST(ptrdiff_t, __m);
        const _CharT* __p = __scan_delim(__buf->_M_gptr(), __last);
        ptrdiff_t __chunk = __p - __buf->_M_gptr();
        __n += __chunk;
        __buf->_M_gbump((int)__chunk);
 
        if (__extract_delim && __p != __last) {
          __n += 1;
          __buf->_M_gbump(1);
        }
 
        __done = true;
      }
 
      else {
        const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr());
        ptrdiff_t __chunk = __p - __buf->_M_gptr();
        __n += __chunk;
        __buf->_M_gbump((int)__chunk);
 
        if (__p != __buf->_M_egptr()) { // We found delim.
          if (__extract_delim) {
            __n += 1;
            __buf->_M_gbump(1);
          }
 
          __done = true;
        }
 
        // We didn't find delim.  Try to refill the buffer.
        else if (__that->_S_eof(__buf->sgetc())) {
          __done   = true;
          __at_eof = true;
        }
      }
    } // Close the while loop.
  }
  _STLP_CATCH_ALL {
    __that->_M_handle_exception(ios_base::badbit);
    return __n;
  }
 
  if (__at_eof)
    __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit
                                   : ios_base::eofbit);
 
  if (__done)
    return __n;
 
  // If execution has reached this point, then we have an empty buffer but
  // we have not reached eof.  What that means is that the streambuf has
  // decided to switch from buffered to unbuffered input.  We switch to
  // to _M_ignore_unbuffered.
 
  return __n + _M_ignore_unbuffered(__that,  __buf, _Num, __max_chars,
                                    __is_delim, __extract_delim, __set_failbit);
}

_M_ignore_unbuffered() [1/2]

template<class _CharT , class _Traits , class _Is_Delim >

void _STLP_CALL _M_ignore_unbuffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__buf,
		_Is_Delim	__is_delim,
		bool	__extract_delim,
		bool	__set_failbit
	)

Definition at line 888 of file _istream.c.

                                                               {
  bool __done = false;
  ios_base::iostate __status = 0;
  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
 
  _STLP_TRY {
    while (!__done) {
      int_type __c = __buf->sbumpc();
 
      if (__that->_S_eof(__c)) {
        __done = true;
        __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
                                  : ios_base::eofbit;
      }
 
      else if (__is_delim(_Traits::to_char_type(__c))) {
        __done = true;
        if (!__extract_delim)
          if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
            __status |= ios_base::failbit;
      }
    }
  }
  _STLP_CATCH_ALL {
    __that->_M_handle_exception(ios_base::badbit);
  }
 
  __that->setstate(__status);
}

Referenced by _M_ignore_buffered(), basic_istream< _CharT, _Traits >::_M_skip_whitespace(), and basic_istream< _CharT, _Traits >::ignore().

_M_ignore_unbuffered() [2/2]

template<class _CharT , class _Traits , class _Max_Chars , class _Is_Delim >

streamsize _STLP_CALL _M_ignore_unbuffered	(	basic_istream< _CharT, _Traits > *	__that,
		basic_streambuf< _CharT, _Traits > *	__buf,
		streamsize	_Num,
		_Max_Chars	__max_chars,
		_Is_Delim	__is_delim,
		bool	__extract_delim,
		bool	__set_failbit
	)

Definition at line 983 of file _istream.c.

                                                               {
  streamsize __n = 0;
  ios_base::iostate __status = 0;
  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;
 
  _STLP_TRY {
    while (__max_chars(_Num, __n) > 0) {
      int_type __c = __buf->sbumpc();
 
      if (__that->_S_eof(__c)) {
        __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit
                                  : ios_base::eofbit;
        break;
      }
 
      else if (__is_delim(_Traits::to_char_type(__c))) {
        if (__extract_delim)
          ++__n;
        else if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))
          __status |= ios_base::failbit;
 
        break;
      }
      // fbp : added counter increment to pass Dietmar's test
      ++__n;
    }
  }
  _STLP_CATCH_ALL {
    __that->_M_handle_exception(ios_base::badbit);
  }
 
  if (__status)
    __that->setstate(__status);   // This might throw.
  return __n;
}