/*

 * © 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.