mirror of
https://github.com/reactos/reactos.git
synced 2024-09-21 02:01:15 +00:00
1430 lines
47 KiB
C
1430 lines
47 KiB
C
|
/*
|
||
|
* 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
|
||
|
# include <stl/_istream.h>
|
||
|
#endif
|
||
|
|
||
|
#ifndef _STLP_INTERNAL_LIMITS
|
||
|
# 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.
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
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;
|
||
|
}
|
||
|
|
||
|
//----------------------------------------------------------------------
|
||
|
// 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
|
||
|
__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 {
|
||
|
// 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;
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (short& __val) {
|
||
|
long __lval;
|
||
|
_STLP_PRIV __get_num(*this, __lval);
|
||
|
if ( this->fail() ) {
|
||
|
return *this;
|
||
|
}
|
||
|
short __tmp = __STATIC_CAST(short, __lval);
|
||
|
unsigned short __uval = __STATIC_CAST(unsigned short, __lval);
|
||
|
// check if we lose digits
|
||
|
// if ((__val != __lval) && ((unsigned short)__val != __lval))
|
||
|
if ((__tmp != __lval) && ((long)__uval != __lval))
|
||
|
this->setstate(ios_base::failbit);
|
||
|
else
|
||
|
__val = __tmp;
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (int& __val) {
|
||
|
long __lval;
|
||
|
_STLP_PRIV __get_num(*this, __lval);
|
||
|
if ( this->fail() ) {
|
||
|
return *this;
|
||
|
}
|
||
|
int __tmp = __lval;
|
||
|
unsigned int __uval = __lval;
|
||
|
// check if we lose digits
|
||
|
// if ((__val != __lval) && ((unsigned int)__val != __lval))
|
||
|
if ((__tmp != __lval) && ((long)__uval != __lval))
|
||
|
this->setstate(ios_base::failbit);
|
||
|
else
|
||
|
__val = __tmp;
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned short& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned int& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned long& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
#if defined (_STLP_LONG_LONG)
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (_STLP_LONG_LONG& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned _STLP_LONG_LONG& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (float& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (double& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
#if !defined (_STLP_NO_LONG_DOUBLE)
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long double& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
#if !defined (_STLP_NO_BOOL)
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (bool& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (void*& __val) {
|
||
|
_STLP_PRIV __get_num(*this, __val);
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
// 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);
|
||
|
}
|
||
|
if (this->_S_eof(__tmp))
|
||
|
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 {
|
||
|
if (this->_S_eof(__buf->sungetc()))
|
||
|
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() {
|
||
|
sentry __sentry(*this, _No_Skip_WS());
|
||
|
|
||
|
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) {
|
||
|
sentry __sentry(*this, _No_Skip_WS());
|
||
|
|
||
|
basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
|
||
|
if (!this->fail() && __buf) {
|
||
|
if (__buf->pubseekpos(__pos, ios_base::in) == pos_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) {
|
||
|
sentry __sentry(*this, _No_Skip_WS());
|
||
|
|
||
|
basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
|
||
|
if (!this->fail() && __buf)
|
||
|
__buf->pubseekoff(__off, __dir, ios_base::in);
|
||
|
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.
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template < class _CharT, class _Traits, class _Is_Delim>
|
||
|
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)
|
||
|
{
|
||
|
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;
|
||
|
}
|
||
|
|
||
|
// Much like __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
|
||
|
__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();
|
||
|
//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);
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
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 =
|
||
|
_STLP_PRIV __read_buffered(this, __buf, __n - 1, __s,
|
||
|
_STLP_PRIV _Eq_char_bound<_Traits>(__delim),
|
||
|
_STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
|
||
|
false, true, false);
|
||
|
else
|
||
|
this->_M_gcount =
|
||
|
_STLP_PRIV __read_unbuffered(this, __buf, __n - 1, __s,
|
||
|
_STLP_PRIV _Eq_char_bound<_Traits>(__delim),
|
||
|
false, true, false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
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()
|
||
|
? _STLP_PRIV __read_buffered(this, __buf, __n - 1, __s,
|
||
|
_STLP_PRIV _Eq_char_bound<_Traits>(__delim),
|
||
|
_STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
|
||
|
true, true, true)
|
||
|
: _STLP_PRIV __read_unbuffered(this, __buf, __n - 1, __s,
|
||
|
_STLP_PRIV _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
|
||
|
= _STLP_PRIV __read_buffered(this, __buf, __n, __s,
|
||
|
_STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
|
||
|
_STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
|
||
|
false, false, false);
|
||
|
else
|
||
|
_M_gcount
|
||
|
= _STLP_PRIV __read_unbuffered(this, __buf, __n, __s,
|
||
|
_STLP_PRIV _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
|
||
|
= _STLP_PRIV __read_buffered(this, __buf, (min) (__avail, __nmax), __s,
|
||
|
_STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
|
||
|
_STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
|
||
|
false, false, false);
|
||
|
else
|
||
|
_M_gcount
|
||
|
= _STLP_PRIV __read_unbuffered(this, __buf, (min) (__avail, __nmax), __s,
|
||
|
_STLP_PRIV _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
|
||
|
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()
|
||
|
? _STLP_PRIV __read_buffered(this, __buf, __nmax, __s,
|
||
|
_STLP_PRIV _Is_wspace_null<_Traits>(this->_M_ctype_facet()),
|
||
|
_STLP_PRIV _Scan_wspace_null<_Traits>(this->_M_ctype_facet()),
|
||
|
false, true, false)
|
||
|
: _STLP_PRIV __read_unbuffered(this, __buf, __nmax, __s,
|
||
|
_STLP_PRIV _Is_wspace_null<_Traits>(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 {
|
||
|
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);
|
||
|
}
|
||
|
|
||
|
// 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());
|
||
|
} // 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);
|
||
|
}
|
||
|
|
||
|
// Overloaded versions of _M_ignore_unbuffered and _M_ignore_unbuffered
|
||
|
// with an explicit count _Num. Return value is the number of
|
||
|
// characters extracted.
|
||
|
//
|
||
|
// The function object __max_chars takes two arguments, _Num and __n
|
||
|
// (the latter being the number of characters we have already read),
|
||
|
// and returns the maximum number of characters to read from the buffer.
|
||
|
// We parameterize _M_ignore_buffered so that we can use it for both
|
||
|
// bounded and unbounded input; for the former the function object should
|
||
|
// be minus<>, and for the latter it should return a constant maximum value.
|
||
|
|
||
|
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) {
|
||
|
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;
|
||
|
}
|
||
|
|
||
|
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) {
|
||
|
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);
|
||
|
}
|
||
|
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>&
|
||
|
basic_istream<_CharT, _Traits>::ignore(streamsize __n) {
|
||
|
sentry __sentry(*this, _No_Skip_WS());
|
||
|
this->_M_gcount = 0;
|
||
|
|
||
|
if (__sentry) {
|
||
|
basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
|
||
|
typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
|
||
|
typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize> _Const_streamsize;
|
||
|
const streamsize __maxss = (numeric_limits<streamsize>::max)();
|
||
|
|
||
|
if (__n == (numeric_limits<int>::max)()) {
|
||
|
if (__buf->gptr() != __buf->egptr())
|
||
|
_M_gcount = _M_ignore_buffered(this, __buf,
|
||
|
__maxss, _Const_streamsize(__maxss),
|
||
|
_Const_bool(false),
|
||
|
_STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
|
||
|
false, false);
|
||
|
else
|
||
|
_M_gcount = _M_ignore_unbuffered(this, __buf,
|
||
|
__maxss, _Const_streamsize(__maxss),
|
||
|
_Const_bool(false), false, false);
|
||
|
}
|
||
|
else {
|
||
|
if (__buf->gptr() != __buf->egptr())
|
||
|
_M_gcount = _M_ignore_buffered(this, __buf,
|
||
|
__n, minus<streamsize>(),
|
||
|
_Const_bool(false),
|
||
|
_STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
|
||
|
false, false);
|
||
|
else
|
||
|
_M_gcount = _M_ignore_unbuffered(this, __buf, __n, minus<streamsize>(),
|
||
|
_Const_bool(false), false, false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>&
|
||
|
basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __delim) {
|
||
|
sentry __sentry(*this, _No_Skip_WS());
|
||
|
this->_M_gcount = 0;
|
||
|
|
||
|
if (__sentry) {
|
||
|
basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
|
||
|
typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool;
|
||
|
typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize>
|
||
|
_Const_streamsize;
|
||
|
const streamsize __maxss = (numeric_limits<streamsize>::max)();
|
||
|
|
||
|
if (__n == (numeric_limits<int>::max)()) {
|
||
|
if (__buf->gptr() != __buf->egptr())
|
||
|
_M_gcount = _M_ignore_buffered(this, __buf,
|
||
|
__maxss, _Const_streamsize(__maxss),
|
||
|
_STLP_PRIV _Eq_int_bound<_Traits>(__delim),
|
||
|
_STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
|
||
|
true, false);
|
||
|
else
|
||
|
_M_gcount = _M_ignore_unbuffered(this, __buf,
|
||
|
__maxss, _Const_streamsize(__maxss),
|
||
|
_STLP_PRIV _Eq_int_bound<_Traits>(__delim),
|
||
|
true, false);
|
||
|
}
|
||
|
else {
|
||
|
if (__buf->gptr() != __buf->egptr())
|
||
|
_M_gcount = _M_ignore_buffered(this, __buf,
|
||
|
__n, minus<streamsize>(),
|
||
|
_STLP_PRIV _Eq_int_bound<_Traits>(__delim),
|
||
|
_STLP_PRIV _Scan_for_int_val<_Traits>(__delim),
|
||
|
true, false);
|
||
|
else
|
||
|
_M_gcount = _M_ignore_unbuffered(this, __buf, __n, minus<streamsize>(),
|
||
|
_STLP_PRIV _Eq_int_bound<_Traits>(__delim),
|
||
|
true, false);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
// This member function does not construct a sentry object, because
|
||
|
// it is called from sentry's constructor.
|
||
|
template <class _CharT, class _Traits>
|
||
|
void basic_istream<_CharT, _Traits>::_M_skip_whitespace(bool __set_failbit) {
|
||
|
basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf();
|
||
|
if (!__buf)
|
||
|
this->setstate(ios_base::badbit);
|
||
|
else if (__buf->gptr() != __buf->egptr())
|
||
|
_M_ignore_buffered(this, __buf,
|
||
|
_STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()),
|
||
|
_STLP_PRIV _Scan_for_not_wspace<_Traits>(this->_M_ctype_facet()),
|
||
|
false, __set_failbit);
|
||
|
else
|
||
|
_M_ignore_unbuffered(this, __buf,
|
||
|
_STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()),
|
||
|
false, __set_failbit);
|
||
|
}
|
||
|
|
||
|
|
||
|
// This is a very simple loop that reads characters from __src and puts
|
||
|
// them into __dest. It looks complicated because of the (standard-
|
||
|
// mandated) exception handling policy.
|
||
|
//
|
||
|
// We stop when we get an exception, when we fail to insert into the
|
||
|
// output streambuf, or when __is_delim is true.
|
||
|
|
||
|
_STLP_MOVE_TO_PRIV_NAMESPACE
|
||
|
|
||
|
template < class _CharT, class _Traits, class _Is_Delim>
|
||
|
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) {
|
||
|
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;
|
||
|
}
|
||
|
|
||
|
// Buffered copying from one streambuf to another. We copy the characters
|
||
|
// in chunks, rather than one at a time. We still have to worry about all
|
||
|
// of the error conditions we checked in __copy_unbuffered, plus one more:
|
||
|
// the streambuf might decide to switch from a buffered to an unbuffered mode.
|
||
|
|
||
|
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) {
|
||
|
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;
|
||
|
}
|
||
|
|
||
|
_STLP_MOVE_TO_STD_NAMESPACE
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>&
|
||
|
basic_istream<_CharT, _Traits>
|
||
|
::get(basic_streambuf<_CharT, _Traits>& __dest, _CharT __delim) {
|
||
|
sentry __sentry(*this, _No_Skip_WS());
|
||
|
this->_M_gcount = 0;
|
||
|
|
||
|
if (__sentry) {
|
||
|
basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
|
||
|
|
||
|
if (__src)
|
||
|
this->_M_gcount = __src->egptr() != __src->gptr()
|
||
|
? _STLP_PRIV __copy_buffered(this, __src, &__dest,
|
||
|
_STLP_PRIV _Scan_for_char_val<_Traits>(__delim),
|
||
|
_STLP_PRIV _Eq_char_bound<_Traits>(__delim),
|
||
|
false, false)
|
||
|
: _STLP_PRIV __copy_unbuffered(this, __src, &__dest,
|
||
|
_STLP_PRIV _Eq_char_bound<_Traits>(__delim),
|
||
|
false, false);
|
||
|
}
|
||
|
|
||
|
if (this->_M_gcount == 0)
|
||
|
this->setstate(ios_base::failbit);
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
// Copying characters into a streambuf.
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_istream<_CharT, _Traits>&
|
||
|
basic_istream<_CharT, _Traits>
|
||
|
::operator>>(basic_streambuf<_CharT, _Traits>* __dest) {
|
||
|
streamsize __n = 0;
|
||
|
typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry;
|
||
|
_Sentry __sentry(*this);
|
||
|
if (__sentry) {
|
||
|
basic_streambuf<_CharT, _Traits>* __src = this->rdbuf();
|
||
|
if (__src && __dest)
|
||
|
__n = __src->egptr() != __src->gptr()
|
||
|
? _STLP_PRIV __copy_buffered(this, __src, __dest,
|
||
|
_STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(),
|
||
|
_STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
|
||
|
false, true)
|
||
|
: _STLP_PRIV __copy_unbuffered(this, __src, __dest,
|
||
|
_STLP_PRIV _Constant_unary_fun<bool, int_type>(false),
|
||
|
false, true);
|
||
|
}
|
||
|
|
||
|
if (__n == 0)
|
||
|
this->setstate(ios_base::failbit);
|
||
|
|
||
|
return *this;
|
||
|
}
|
||
|
|
||
|
// ----------------------------------------------------------------
|
||
|
// basic_iostream<> class
|
||
|
// ----------------------------------------------------------------
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_iostream<_CharT, _Traits>
|
||
|
::basic_iostream(basic_streambuf<_CharT, _Traits>* __buf)
|
||
|
: basic_ios<_CharT, _Traits>(),
|
||
|
basic_istream<_CharT, _Traits>(__buf),
|
||
|
basic_ostream<_CharT, _Traits>(__buf) {
|
||
|
this->init(__buf);
|
||
|
}
|
||
|
|
||
|
template <class _CharT, class _Traits>
|
||
|
basic_iostream<_CharT, _Traits>::~basic_iostream()
|
||
|
{}
|
||
|
|
||
|
_STLP_END_NAMESPACE
|
||
|
|
||
|
#undef __BIS_int_type__
|
||
|
#undef __BIS_pos_type__
|
||
|
#undef __BIS_off_type__
|
||
|
|
||
|
#endif /* _STLP_ISTREAM_C */
|
||
|
|
||
|
// Local Variables:
|
||
|
// mode:C++
|
||
|
// End:
|