/*

 * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

 * Copyright (c) 1999

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

#ifndef _STLP_ISTREAM_C

#define _STLP_ISTREAM_C

#ifndef _STLP_INTERNAL_ISTREAM_H

# include <stl/_istream.h>

#endif

# if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION)

#ifndef _STLP_LIMITS_H

# include <stl/_limits.h>

#endif

#ifndef _STLP_INTERNAL_NUM_GET_H

# include <stl/_num_get.h>

#endif

# if defined ( _STLP_NESTED_TYPE_PARAM_BUG )

// no wchar_t is supported for this mode

# define __BIS_int_type__ int

# define __BIS_pos_type__ streampos

# define __BIS_off_type__ streamoff

# else

# 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

# endif

_STLP_BEGIN_NAMESPACE

//----------------------------------------------------------------------

// Function object structs used by some member functions.

template <class _Traits>

struct _Is_not_wspace {

  typedef typename _Traits::char_type argument_type;

  typedef bool                        result_type;

  const ctype<argument_type>* _M_ctype;

  _Is_not_wspace(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}

  bool operator()(argument_type __c) const

    { return !_M_ctype->is(ctype_base::space, __c); }

};

template <class _Traits>

struct _Is_wspace_null {

  typedef typename _Traits::char_type argument_type;

  typedef bool                        result_type;

  const ctype<argument_type>* _M_ctype;

  _Is_wspace_null(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {}

  bool operator()(argument_type __c) const {

    return _Traits::eq(__c, argument_type()) ||

           _M_ctype->is(ctype_base::space, __c);

  }

};

template <class _Traits>

struct _Scan_for_wspace {

  typedef typename _Traits::char_type  char_type;

  typedef char_type*                   first_argument_type;

  typedef char_type*                   second_argument_type;

  typedef char_type*                   result_type;

  const ctype<char_type>* _M_ctype;

  _Scan_for_wspace(const ctype<char_type>* __ctype) : _M_ctype(__ctype) {}

  const char_type*

  operator()(const char_type* __first, const char_type* __last) const {

    return _M_ctype->scan_is(ctype_base::space, __first, __last);

  }

};

template <class _Traits>

struct _Scan_wspace_null {

  typedef typename _Traits::char_type  char_type;

  typedef char_type*                   first_argument_type;

  typedef char_type*                   second_argument_type;

  typedef char_type*                   result_type;

  const ctype<char_type>* _M_ctype;

  _Scan_wspace_null(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}

  const char_type*

  operator()(const char_type* __first, const char_type* __last) const {

    __last = find_if(__first, __last,

                     _Eq_char_bound<_Traits>(char_type()));

    return _M_ctype->scan_is(ctype_base::space, __first, __last);

  }

};

template <class _Traits>

struct _Scan_for_not_wspace {

  typedef typename _Traits::char_type  char_type;

  typedef char_type*                   first_argument_type;

  typedef char_type*                   second_argument_type;

  typedef char_type*                   result_type;

  const ctype<char_type>* _M_ctype;

  _Scan_for_not_wspace(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {}

  const char_type*

  operator()(const char_type* __first, const char_type* __last) const {

    return _M_ctype->scan_not(ctype_base::space, __first, __last);

  }

};

template <class _Traits>

struct _Scan_for_char_val

{

  typedef typename _Traits::char_type char_type;

  typedef char_type*                  first_argument_type;

  typedef char_type*                  second_argument_type;

  typedef char_type*                  result_type;

  char_type _M_val;

  _Scan_for_char_val(char_type __val) : _M_val(__val) {}

  const char_type*

  operator()(const char_type* __first, const char_type* __last) const {

    return find_if(__first, __last, _Eq_char_bound<_Traits>(_M_val));

  }

};

template <class _Traits>

struct _Scan_for_int_val

{

  typedef typename _Traits::char_type char_type;

  typedef typename _Traits::int_type  int_type;

  typedef char_type*                  first_argument_type;

  typedef char_type*                  second_argument_type;

  typedef char_type*                  result_type;

  int_type _M_val;

  _Scan_for_int_val(int_type __val) : _M_val(__val) {}

  const char_type*

  operator()(const char_type* __first, const char_type* __last) const {

    return find_if(__first, __last,

                   _Eq_int_bound<_Traits>(_M_val));

  }

};

// Helper function: try to push back a character to a streambuf,

// return true if the pushback succeeded.  Does not throw.

template <class _CharT, class _Traits>

bool _STLP_CALL

__pushback(basic_streambuf<_CharT, _Traits>* __buf, _CharT __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;

}

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>& _STLP_CALL

ws(basic_istream<_CharT, _Traits>& __is)

{

  typedef typename basic_istream<_CharT, _Traits>::sentry      _Sentry;

  _Sentry __sentry(__is, _No_Skip_WS()); // Don't skip whitespace.

  if (__sentry)

    __is._M_skip_whitespace(false);

  return __is;

}

// Helper functions for istream<>::sentry constructor.

template <class _CharT, class _Traits>

bool

_M_init_skip(basic_istream<_CharT, _Traits>& __is) {

  if (__is.good()) {

    if (__is.tie())

      __is.tie()->flush();

    __is._M_skip_whitespace(true);

  }

  if (!__is.good()) {

    __is.setstate(ios_base::failbit);

    return false;

  } else

    return true;

}

template <class _CharT, class _Traits>

bool

_M_init_noskip(basic_istream<_CharT, _Traits>& __is){

  if (__is.good()) {

    if (__is.tie())

      __is.tie()->flush();

    if (!__is.rdbuf())

      __is.setstate(ios_base::badbit);

  }

  else

    __is.setstate(ios_base::failbit);

  return __is.good();

}

//----------------------------------------------------------------------

// Definitions of basic_istream<>'s noninline member functions.

// Helper function for formatted input of numbers.

template <class _CharT, class _Traits, class _Number>

ios_base::iostate _STLP_CALL

_M_get_num(basic_istream<_CharT, _Traits>& __that, _Number& __val)

{

  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 {

      ((const _Num_get&)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;

}

// Unformatted input

template <class _CharT, class _Traits>

__BIS_int_type__

basic_istream<_CharT, _Traits>::peek()

{

  typename _Traits::int_type __tmp = _Traits::eof();

  this->_M_gcount = 0;

  sentry __sentry(*this, _No_Skip_WS());

  if (__sentry) {

    _STLP_TRY {

      __tmp = this->rdbuf()->sgetc();

    }

    _STLP_CATCH_ALL {

      this->_M_handle_exception(ios_base::badbit);

    }

  }

  else

  {

    if (this->_S_eof(__tmp))

    {

      this->clear();

      this->setstate(ios_base::eofbit);

    }

  }

  return __tmp;

}

template <class _CharT, class _Traits>

__BIS_int_type__

basic_istream<_CharT, _Traits>::get()

{

  typename _Traits::int_type __tmp = _Traits::eof();

  sentry __sentry(*this, _No_Skip_WS());

  this->_M_gcount = 0;

  if (__sentry) {

    _STLP_TRY {

      __tmp = this->rdbuf()->sbumpc();

    }

    _STLP_CATCH_ALL {

      this->_M_handle_exception(ios_base::badbit);

    }

    if (!this->_S_eof(__tmp))

      this->_M_gcount = 1;

  }

  if (_M_gcount == 0)

    this->setstate(ios_base::eofbit | ios_base::failbit);

  return __tmp;

}

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::get(_CharT& __c)

{

  sentry __sentry(*this, _No_Skip_WS());

  this->_M_gcount = 0;

  if (__sentry) {

    typename _Traits::int_type __tmp = _Traits::eof();

    _STLP_TRY {

      __tmp = this->rdbuf()->sbumpc();

    }

    _STLP_CATCH_ALL {

      this->_M_handle_exception(ios_base::badbit);

    }

    if (!this->_S_eof(__tmp)) {

      this->_M_gcount = 1;

      __c = _Traits::to_char_type(__tmp);

    }

  }

  if (this->_M_gcount == 0)

    this->setstate(ios_base::eofbit | ios_base::failbit);

  return *this;

}

// Read characters and discard them.  The standard specifies a single

// function with two arguments, each with a default.  We instead use

// three overloded functions, because it's possible to implement the

// first two more efficiently than the fully general third version.

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::ignore()

{

  sentry __sentry(*this, _No_Skip_WS());

  this->_M_gcount = 0;

  if (__sentry) {

    int_type __c;

    _STLP_TRY {

      __c = this->rdbuf()->sbumpc();

    }

    _STLP_CATCH_ALL {

      this->_M_handle_exception(ios_base::badbit);

      return *this;

    }

    if (!this->_S_eof(__c))

      this->_M_gcount = 1;

    else

      this->setstate(ios_base::eofbit);

  }

  return *this;

}

// Putback

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::putback(_CharT __c) {

  this->_M_gcount = 0;

  sentry __sentry(*this, _No_Skip_WS());

  if (__sentry) {

    typename _Traits::int_type __tmp = _Traits::eof();

    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

//    if (!__buf || this->_S_eof(__buf->sputbackc(__c)))

    if (__buf) {

      _STLP_TRY {

        __tmp = __buf->sputbackc(__c);

      }

      _STLP_CATCH_ALL {

        this->_M_handle_exception(ios_base::badbit);

      }

    }

    if (this->_S_eof(__tmp))

      this->setstate(ios_base::badbit);

  }

  else

    this->setstate(ios_base::failbit);

  return *this;

}

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::unget() {

  this->_M_gcount = 0;

  sentry __sentry(*this, _No_Skip_WS());

  if (__sentry) {

    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

    //     if (!__buf || _Traits::eq_int_type(__buf->sungetc(), _Traits::eof()))

    if (__buf) {

      _STLP_TRY {

        _CharT __tmp;

        __tmp = __buf->sungetc();

#ifdef 	__SYMBIAN32__

	if (__tmp == (_CharT)-1) //chek for eof

#else

        if (this->_S_eof(__tmp))

#endif			

          this->setstate(ios_base::badbit);

      }

      _STLP_CATCH_ALL {

        this->_M_handle_exception(ios_base::badbit);

      }

    } else

      this->setstate(ios_base::badbit);

  }

  else

    this->setstate(ios_base::failbit);

  return *this;

}

// Positioning and buffer control.

template <class _CharT, class _Traits>

int basic_istream<_CharT, _Traits>::sync() {

  sentry __sentry(*this, _No_Skip_WS());

  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

  if (__buf) {

    if (__buf->pubsync() == -1) {

      this->setstate(ios_base::badbit);

      return -1;

    }

    else

      return 0;

  }

  else

    return -1;

}

template <class _CharT, class _Traits>

__BIS_pos_type__

basic_istream<_CharT, _Traits>::tellg() {

#ifndef __SYMBIAN32__

  sentry __sentry(*this, _No_Skip_WS());

#endif

  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

  return (__buf && !this->fail()) ? __buf->pubseekoff(0, ios_base::cur, ios_base::in)

    : pos_type(-1);

}

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::seekg(pos_type __pos) {

#ifndef __SYMBIAN32__

  sentry __sentry(*this, _No_Skip_WS());

#endif

  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

  if (!this->fail() && __buf)

  {

    pos_type pos = __buf->pubseekpos(__pos, ios_base::in);

    if(pos == pos_type(off_type(-1)))

    	this->setstate(ios_base::failbit);

  }

  return *this;

}

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)

{

#ifndef __SYMBIAN32__

  sentry __sentry(*this, _No_Skip_WS());

#endif

  basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

  if (!this->fail() && __buf)

  {

    pos_type pos = __buf->pubseekoff(__off, __dir, ios_base::in);

    if(pos == pos_type(off_type(-1)))

     	this->setstate(ios_base::failbit);

  }

  return *this;

}

// Formatted input of characters and character arrays.

template <class _CharT, class _Traits>

void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT& __c)

{

//  typename _Traits::int_type __tmp = _Traits::eof();

  sentry __sentry(*this); // Skip whitespace.

  if (__sentry) {

    typename _Traits::int_type __tmp = _Traits::eof();

    _STLP_TRY {

      __tmp = this->rdbuf()->sbumpc();

    }

    _STLP_CATCH_ALL {

      this->_M_handle_exception(ios_base::badbit);

      return;

    }

    if (!this->_S_eof(__tmp))

      __c = _Traits::to_char_type(__tmp);

    else

      this->setstate(ios_base::eofbit | ios_base::failbit);

  }

}

//---------------------------------------------------------------------------

// istream's helper functions.

// A generic function for unbuffered input.  We stop when we reach EOF,

// or when we have extracted _Num characters, or when the function object

// __is_delim return true.  In the last case, it extracts the character

// for which __is_delim is true, if and only if __extract_delim is true.

// It appends a null character to the end of the string; this means that

// it may store up to _Num + 1 characters.

//

// __is_getline governs two corner cases: reading _Num characters without

// encountering delim or eof (in which case failbit is set if __is_getline

// is true); and reading _Num characters where the _Num+1'st character is

// eof (in which case eofbit is set if __is_getline is true).

//

// It is assumed that __is_delim never throws.

//

// Return value is the number of characters extracted, including the

// delimiter if it is extracted.  Note that the number of characaters

// extracted isn't necessarily the same as the number stored.

template < class _CharT, class _Traits, class _Is_Delim>

streamsize _STLP_CALL

_M_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)

{

  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 {

# if 0

    int_type __c = __buf->sgetc();

    while (true) {

      if (__that->_S_eof(__c)) {

        if (__n < _Num || __is_getline)

          __status |= ios_base::eofbit;

        break;

      }

      else if (__is_delim(__c)) {

        if (__extract_delim) {  // Extract and discard current character.

          __buf->sbumpc();

          ++__n;

        }

        break;

      }

      else if (__n == _Num) {

        if (__is_getline)

          __status |= ios_base::failbit;

        break;

      }

      *__s++ = _Traits::to_char_type(__c);

      ++__n;

      __c = __buf->snextc();

    }

# else

// int_type __c = __buf->sbumpc(); // __buf->sgetc();

while (true) {

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(__c)) {

if (__extract_delim) { // Extract and discard current character.

// __buf->sbumpc();

++__n;

}

break;

}

else { // regular character

*__s++ = _Traits::to_char_type(__c);

++__n;

}

if (__n == _Num) {

if (__is_getline) // didn't find delimiter as one of the _Num chars

__status |= ios_base::failbit;

break;

}

// *__s++ = _Traits::to_char_type(__c);

// ++__n;

}

# endif

  }

  _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;

}

// Much like _M_read_unbuffered, but with one additional function object:

// __scan_delim(first, last) returns the first pointer p in [first, last)

// such that __is_delim(p) is true.

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

streamsize _STLP_CALL

_M_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)

{

  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();

      ptrdiff_t __request = _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 _M_read_unbuffered.

  return __n + _M_read_unbuffered(__that,  __buf, _Num - __n, __s, __is_delim,

                                  __extract_delim,__append_null,__is_getline);

}

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::get(_CharT* __s, streamsize __n,

                                    _CharT __delim) {

  sentry __sentry(*this, _No_Skip_WS());

  this->_M_gcount = 0;

  if (__sentry) {

    if (__n > 0) {

      basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

      if (__buf->egptr() != __buf->gptr())

        this->_M_gcount =

          _M_read_buffered(this,  __buf, __n - 1, __s,

                           _Eq_char_bound<_Traits>(__delim),

                           _Scan_for_char_val<_Traits>(__delim),

                           false, true, false);

      else

        this->_M_gcount =

          _M_read_unbuffered(this,  __buf, __n - 1, __s,

                             _Eq_char_bound<_Traits>(__delim),

                             false, true, false);

    }

  }

#ifdef __SYMBIAN32__

  *(__s + this->_M_gcount) = _STLP_DEFAULT_CONSTRUCTED(_CharT);

#endif //__SYMBIAN32__  

  if (this->_M_gcount == 0)

    this->setstate(ios_base::failbit);

  return *this;

}

// Getline is essentially identical to get, except that it extracts

// the delimiter.

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n,

                                        _CharT __delim) {

  sentry __sentry(*this, _No_Skip_WS());

  this->_M_gcount = 0;

  if (__sentry) {

    if (__n > 0) {

      basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

      this->_M_gcount = __buf->egptr() != __buf->gptr()

        ? _M_read_buffered(this,  __buf, __n - 1, __s,

                           _Eq_char_bound<_Traits>(__delim),

                           _Scan_for_char_val<_Traits>(__delim),

                           true, true, true)

        : _M_read_unbuffered(this,  __buf, __n - 1, __s,

                             _Eq_char_bound<_Traits>(__delim),

                             true, true, true);

    }

  }

  if (this->_M_gcount == 0)

    this->setstate(ios_base::failbit);

  return *this;

}

// Read n characters.  We don't look for any delimiter, and we don't

// put in a terminating null character.

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)

{

  sentry __sentry(*this, _No_Skip_WS());

  this->_M_gcount = 0;

  if (__sentry && !this->eof()) {

    basic_streambuf<_CharT, _Traits>*__buf = this->rdbuf();

    if (__buf->gptr() != __buf->egptr())

      _M_gcount

        = _M_read_buffered(this,  __buf, __n, __s,

                           _Constant_unary_fun<bool, int_type>(false),

                           _Project2nd<const _CharT*, const _CharT*>(),

                           false, false, false);

    else

      _M_gcount

        = _M_read_unbuffered(this,  __buf, __n, __s,

                             _Constant_unary_fun<bool, int_type>(false),

                             false, false, false);

  }

  else

    this->setstate(ios_base::failbit);

  if (this->eof())

    this->setstate(ios_base::eofbit | ios_base::failbit);

  return *this;

}

// Read n or fewer characters.  We don't look for any delimiter, and

// we don't put in a terminating null character.

template <class _CharT, class _Traits>

streamsize

basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __nmax)

{

  sentry __sentry(*this, _No_Skip_WS());

  this->_M_gcount = 0;

  if (__sentry && !this->eof() && __nmax >= 0) {

    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

    streamsize __avail = __buf->in_avail();

    // fbp : isn't full-blown setstate required here ?

    if (__avail == -1)

      this->_M_setstate_nothrow(ios_base::eofbit);

    else if (__avail != 0) {

      if (__buf->gptr() != __buf->egptr())

        _M_gcount

          = _M_read_buffered(this,  __buf, (min) (__avail, __nmax), __s,

                             _Constant_unary_fun<bool, int_type>(false),

                             _Project2nd<const _CharT*, const _CharT*>(),

                             false, false, false);

      else

        _M_gcount

          = _M_read_unbuffered(this,  __buf, (min) (__avail, __nmax), __s,

                               _Constant_unary_fun<bool, int_type>(false),

                               false, false, false);

    }

  }

  else {

    // fbp : changed so that failbit is set only there, to pass Dietmar's test

    if (this->eof())

      this->setstate(ios_base::eofbit | ios_base::failbit);

    else

      {

      if (__nmax < 0)

        {

        basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

        streamsize __avail = __buf->in_avail();

        if(__avail == -1)

            this->setstate(ios_base::eofbit);

        }

      else

        this->setstate(ios_base::failbit);

      }

  }

  //  if (this->eof())

  //    this->setstate(ios_base::eofbit | ios_base::failbit);

  return _M_gcount;

}

template <class _CharT, class _Traits>

void basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT* __s)

{

  sentry __sentry(*this); // Skip whitespace.

  if (__sentry) {

    basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();

    streamsize __nmax = this->width() > 0

      ? this->width() - 1

      : (numeric_limits<streamsize>::max)() / sizeof(_CharT) - 1;

    streamsize __n = __buf->gptr() != __buf->egptr()

      ? _M_read_buffered(this,  __buf, __nmax, __s,

                         _Is_wspace_null<_Traits>((const ctype<_CharT>*)this->_M_ctype_facet()),

                         _Scan_wspace_null<_Traits>((const ctype<_CharT>*)this->_M_ctype_facet()),

			 false, true, false)

      : _M_read_unbuffered(this,  __buf, __nmax, __s,

                           _Is_wspace_null<_Traits>((const ctype<_CharT>*)this->_M_ctype_facet()),

			   false, true, false);

    if (__n == 0)

      this->setstate(ios_base::failbit);

  }

  this->width(0);

}

// A generic unbuffered function for ignoring characters.  We stop

// when we reach EOF, or when the function object __is_delim returns

// true.  In the last case, it extracts the character for which

// __is_delim is true, if and only if __extract_delim is true.

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)

{

  bool __done = false;

  ios_base::iostate __status = 0;

  typedef typename basic_istream<_CharT, _Traits>::int_type int_type;

  _STLP_TRY {

#ifdef __SYMBIAN32__

    int_type __c = __buf->sgetc();

    do {

      if (__that->_S_eof(__c)) {

        __done = true;

        __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit

                                  : ios_base::eofbit;

        break;

      }

      else if (__is_delim(__c)) {

        __done = true;

        if (__extract_delim)

            __buf->snextc();

        break;

        }

      __c = __buf->snextc();        

      } while(!__done);

#else

    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(__c)) {

        __done = true;

        if (!__extract_delim)

          if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c))))

            __status |= ios_base::failbit;

      }

    }

#endif

  }

  _STLP_CATCH_ALL {

    __that->_M_handle_exception(ios_base::badbit);

  }

  __that->setstate(__status);

}

// A generic buffered function for ignoring characters.  Much like

// _M_ignore_unbuffered, but with one additional function object:

// __scan_delim(first, last) returns the first pointer p in [first,

// last) such that __is_delim(p) is true.

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)

{

  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());