111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert/* 211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Copyright (c) 1999 311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Silicon Graphics Computer Systems, Inc. 411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Copyright (c) 1999 611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Boris Fomitchev 711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * This material is provided "as is", with absolutely no warranty expressed 911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * or implied. Any use is at your own risk. 1011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 1111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Permission to use or copy this software for any purpose is hereby granted 1211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * without fee, provided the above notices are retained on all copies. 1311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * Permission to modify the code and to distribute modified code is granted, 1411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * provided the above notices are retained, and a notice that the code was 1511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * modified is included with the above copyright notice. 1611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert * 1711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert */ 1811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_ISTREAM_C 1911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#define _STLP_ISTREAM_C 2011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_ISTREAM 2211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_istream.h> 2311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 2411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_LIMITS 2611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_limits.h> 2711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 2811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 2911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#ifndef _STLP_INTERNAL_NUM_GET_H 3011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# include <stl/_num_get.h> 3111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 3211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 3311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined ( _STLP_NESTED_TYPE_PARAM_BUG ) 3411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// no wchar_t is supported for this mode 3511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define __BIS_int_type__ int 3611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define __BIS_pos_type__ streampos 3711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define __BIS_off_type__ streamoff 3811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#else 3911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define __BIS_int_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::int_type 4011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define __BIS_pos_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::pos_type 4111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert# define __BIS_off_type__ _STLP_TYPENAME_ON_RETURN_TYPE basic_istream<_CharT, _Traits>::off_type 4211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 4311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_BEGIN_NAMESPACE 4511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 4711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Function object structs used by some member functions. 4811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 4911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_PRIV_NAMESPACE 5011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Traits> 5211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Is_not_wspace { 5311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::char_type argument_type; 5411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef bool result_type; 5511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ctype<argument_type>* _M_ctype; 5711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 5811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_not_wspace(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {} 5911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator()(argument_type __c) const 6011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert { return !_M_ctype->is(ctype_base::space, __c); } 6111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 6211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Traits> 6411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Is_wspace_null { 6511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::char_type argument_type; 6611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef bool result_type; 6711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 6811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ctype<argument_type>* _M_ctype; 6911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_wspace_null(const ctype<argument_type>* __c_type) : _M_ctype(__c_type) {} 7111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool operator()(argument_type __c) const { 7211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _Traits::eq(__c, argument_type()) || 7311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_ctype->is(ctype_base::space, __c); 7411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 7511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 7611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 7711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Traits> 7811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Scan_for_wspace { 7911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::char_type char_type; 8011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* first_argument_type; 8111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* second_argument_type; 8211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* result_type; 8311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ctype<char_type>* _M_ctype; 8511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 8611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Scan_for_wspace(const ctype<char_type>* __ctype) : _M_ctype(__ctype) {} 8711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char_type* 8811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert operator()(const char_type* __first, const char_type* __last) const { 8911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _M_ctype->scan_is(ctype_base::space, __first, __last); 9011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 9111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 9211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 9311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Traits> 9411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Scan_wspace_null { 9511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::char_type char_type; 9611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* first_argument_type; 9711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* second_argument_type; 9811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* result_type; 9911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ctype<char_type>* _M_ctype; 10111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 10211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Scan_wspace_null(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {} 10311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char_type* 10411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert operator()(const char_type* __first, const char_type* __last) const { 10511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __last = find_if(__first, __last, 10611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Eq_char_bound<_Traits>(char_type())); 10711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _M_ctype->scan_is(ctype_base::space, __first, __last); 10811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 10911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 11011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Traits> 11211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Scan_for_not_wspace { 11311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::char_type char_type; 11411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* first_argument_type; 11511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* second_argument_type; 11611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* result_type; 11711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 11811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const ctype<char_type>* _M_ctype; 11911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Scan_for_not_wspace(const ctype<char_type>* __c_type) : _M_ctype(__c_type) {} 12111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char_type* 12211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert operator()(const char_type* __first, const char_type* __last) const { 12311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _M_ctype->scan_not(ctype_base::space, __first, __last); 12411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 12511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 12611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 12711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Traits> 12811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Scan_for_char_val { 12911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::char_type char_type; 13011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* first_argument_type; 13111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* second_argument_type; 13211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* result_type; 13311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert char_type _M_val; 13511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Scan_for_char_val(char_type __val) : _M_val(__val) {} 13711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 13811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char_type* 13911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert operator()(const char_type* __first, const char_type* __last) const { 14011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return find_if(__first, __last, _Eq_char_bound<_Traits>(_M_val)); 14111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 14211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 14311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 14411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _Traits> 14511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstruct _Scan_for_int_val { 14611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::char_type char_type; 14711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename _Traits::int_type int_type; 14811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* first_argument_type; 14911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* second_argument_type; 15011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef char_type* result_type; 15111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int_type _M_val; 15311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Scan_for_int_val(int_type __val) : _M_val(__val) {} 15511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 15611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const char_type* 15711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert operator()(const char_type* __first, const char_type* __last) const { 15811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return find_if(__first, __last, 15911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Eq_int_bound<_Traits>(_M_val)); 16011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 16111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert}; 16211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Helper function: try to push back a character to a streambuf, 16411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// return true if the pushback succeeded. Does not throw. 16511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 16611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 16711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbool _STLP_CALL 16811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__pushback(basic_streambuf<_CharT, _Traits>* __buf, _CharT __c) { 16911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool ret; 17011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 17111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const typename _Traits::int_type __eof = _Traits::eof(); 17211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ret = !_Traits::eq_int_type(__buf->sputbackc(__c), __eof); 17311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 17411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 17511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ret = false; 17611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 17711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return ret; 17811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 17911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//---------------------------------------------------------------------- 18111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Definitions of basic_istream<>'s noninline member functions. 18211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 18311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Helper function for formatted input of numbers. 18411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits, class _Number> 18511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertios_base::iostate _STLP_CALL 18611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__get_num(basic_istream<_CharT, _Traits>& __that, _Number& __val) { 18711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry; 18811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::iostate __err = 0; 18911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Sentry __sentry( __that ); // Skip whitespace. 19011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 19111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > _Num_get; 19211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 19311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Do not remove additional parenthesis around use_facet instanciation, some compilers (VC6) 19411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // require it when building the library. 19511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert (use_facet<_Num_get>(__that.getloc())).get(istreambuf_iterator<_CharT, _Traits>(__that.rdbuf()), 19611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 0, __that, __err, __val); 19711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 19811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 19911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that._M_handle_exception(ios_base::badbit); 20011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 20111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__err) __that.setstate(__err); 20211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 20311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __err; 20411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 20511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_STD_NAMESPACE 20711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 20811cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 20911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (short& __val) { 21011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long __lval; 21111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __lval); 21211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ( this->fail() ) { 21311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 21411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 21511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert short __tmp = __STATIC_CAST(short, __lval); 21611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned short __uval = __STATIC_CAST(unsigned short, __lval); 21711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // check if we lose digits 21811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // if ((__val != __lval) && ((unsigned short)__val != __lval)) 21911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ((__tmp != __lval) && ((long)__uval != __lval)) 22011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 22111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 22211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __val = __tmp; 22311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 22411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 22511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 22611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 22711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (int& __val) { 22811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert long __lval; 22911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __lval); 23011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ( this->fail() ) { 23111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 23211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 23311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int __tmp = __lval; 23411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert unsigned int __uval = __lval; 23511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // check if we lose digits 23611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // if ((__val != __lval) && ((unsigned int)__val != __lval)) 23711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if ((__tmp != __lval) && ((long)__uval != __lval)) 23811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 23911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 24011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __val = __tmp; 24111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 24211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 24311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 24411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 24511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned short& __val) { 24611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 24711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 24811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 24911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 25111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned int& __val) { 25211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 25311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 25411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 25511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 25611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 25711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long& __val) { 25811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 25911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 26011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 26111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 26211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 26311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned long& __val) { 26411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 26511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 26611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 26711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 26811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if defined (_STLP_LONG_LONG) 26911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 27011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (_STLP_LONG_LONG& __val) { 27111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 27211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 27311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 27411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 27511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 27611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (unsigned _STLP_LONG_LONG& __val) { 27711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 27811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 27911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 28011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 28111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 28211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (float& __val) { 28311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 28411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 28511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 28611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 28711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (double& __val) { 28811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 28911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 29011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 29111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined (_STLP_NO_LONG_DOUBLE) 29211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 29311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (long double& __val) { 29411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 29511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 29611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 29711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 29811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#if !defined (_STLP_NO_BOOL) 29911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 30011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (bool& __val) { 30111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 30211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 30311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 30411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif 30511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 30611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 30711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>> (void*& __val) { 30811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __get_num(*this, __val); 30911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 31011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 31111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Unformatted input 31311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 31511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__BIS_int_type__ 31611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::peek() { 31711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typename _Traits::int_type __tmp = _Traits::eof(); 31811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 31911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 32011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 32111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 32211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 32311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 32411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp = this->rdbuf()->sgetc(); 32511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 32611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 32711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_handle_exception(ios_base::badbit); 32811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 32911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->_S_eof(__tmp)) 33011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::eofbit); 33111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 33211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 33411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 33511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 33711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 33811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__BIS_int_type__ 33911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::get() { 34011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typename _Traits::int_type __tmp = _Traits::eof(); 34111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 34211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 34311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 34411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 34511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 34611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp = this->rdbuf()->sbumpc(); 34711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 34811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 34911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_handle_exception(ios_base::badbit); 35011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 35111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!this->_S_eof(__tmp)) 35311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 1; 35411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 35511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (_M_gcount == 0) 35711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::eofbit | ios_base::failbit); 35811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 35911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __tmp; 36011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 36111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 36311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 36411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::get(_CharT& __c) { 36511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 36611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 36711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 36811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 36911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typename _Traits::int_type __tmp = _Traits::eof(); 37011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 37111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp = this->rdbuf()->sbumpc(); 37211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 37311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 37411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_handle_exception(ios_base::badbit); 37511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 37611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 37711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!this->_S_eof(__tmp)) { 37811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 1; 37911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __c = _Traits::to_char_type(__tmp); 38011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 38111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 38211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->_M_gcount == 0) 38411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::eofbit | ios_base::failbit); 38511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 38711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 38811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 38911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Read characters and discard them. The standard specifies a single 39111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// function with two arguments, each with a default. We instead use 39211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// three overloded functions, because it's possible to implement the 39311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// first two more efficiently than the fully general third version. 39411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 39511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::ignore() { 39611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 39711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 39811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 39911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 40011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int_type __c; 40111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 40211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __c = this->rdbuf()->sbumpc(); 40311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 40411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 40511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_handle_exception(ios_base::badbit); 40611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 40711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 40811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 40911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!this->_S_eof(__c)) 41011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 1; 41111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 41211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::eofbit); 41311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 41411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 41611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 41711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 41811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Putback 41911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 42111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 42211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::putback(_CharT __c) { 42311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 42411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 42511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 42611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 42711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typename _Traits::int_type __tmp = _Traits::eof(); 42811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 42911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// if (!__buf || this->_S_eof(__buf->sputbackc(__c))) 43011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf) { 43111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 43211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp = __buf->sputbackc(__c); 43311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 43411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 43511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_handle_exception(ios_base::badbit); 43611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 43711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 43811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->_S_eof(__tmp)) 43911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::badbit); 44011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 44111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 44211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 44311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 44511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 44611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 44711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 44811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::unget() { 44911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 45011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 45211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 45311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 45411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 45511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // if (!__buf || _Traits::eq_int_type(__buf->sungetc(), _Traits::eof())) 45611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf) { 45711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 45811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->_S_eof(__buf->sungetc())) 45911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::badbit); 46011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 46211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_handle_exception(ios_base::badbit); 46311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else 46511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::badbit); 46611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 46711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 46811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 46911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 47111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 47211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Positioning and buffer control. 47411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 47611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertint basic_istream<_CharT, _Traits>::sync() { 47711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 47811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 47911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 48011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf) { 48111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->pubsync() == -1) { 48211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::badbit); 48311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return -1; 48411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 48511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 48611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return 0; 48711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 48811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 48911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return -1; 49011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 49111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 49311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__BIS_pos_type__ 49411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::tellg() { 49511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 49611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 49711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 49811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return (__buf && !this->fail()) ? __buf->pubseekoff(0, ios_base::cur, ios_base::in) 49911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : pos_type(-1); 50011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 50111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 50311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 50411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::seekg(pos_type __pos) { 50511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 50611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 50711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 50811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!this->fail() && __buf) { 50911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->pubseekpos(__pos, ios_base::in) == pos_type(-1)) { 51011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 51111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 51211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 51311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 51411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 51511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 51611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 51711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 51811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) { 51911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 52011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 52211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!this->fail() && __buf) 52311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->pubseekoff(__off, __dir, ios_base::in); 52411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 52511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 52611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Formatted input of characters and character arrays. 52811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 52911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 53011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT& __c) { 53111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// typename _Traits::int_type __tmp = _Traits::eof(); 53211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this); // Skip whitespace. 53411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 53611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typename _Traits::int_type __tmp;// = _Traits::eof(); 53711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 53811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 53911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __tmp = this->rdbuf()->sbumpc(); 54011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 54111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 54211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_handle_exception(ios_base::badbit); 54311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return; 54411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 54511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 54611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!this->_S_eof(__tmp)) 54711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __c = _Traits::to_char_type(__tmp); 54811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 54911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::eofbit | ios_base::failbit); 55011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 55111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 55211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert//--------------------------------------------------------------------------- 55511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// istream's helper functions. 55611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 55711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A generic function for unbuffered input. We stop when we reach EOF, 55811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// or when we have extracted _Num characters, or when the function object 55911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// __is_delim return true. In the last case, it extracts the character 56011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// for which __is_delim is true, if and only if __extract_delim is true. 56111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// It appends a null character to the end of the string; this means that 56211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// it may store up to _Num + 1 characters. 56311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 56411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// __is_getline governs two corner cases: reading _Num characters without 56511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// encountering delim or eof (in which case failbit is set if __is_getline 56611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// is true); and reading _Num characters where the _Num+1'st character is 56711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// eof (in which case eofbit is set if __is_getline is true). 56811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 56911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// It is assumed that __is_delim never throws. 57011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 57111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Return value is the number of characters extracted, including the 57211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// delimiter if it is extracted. Note that the number of characaters 57311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// extracted isn't necessarily the same as the number stored. 57411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_PRIV_NAMESPACE 57611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 57711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Is_Delim> 57811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstreamsize _STLP_CALL 57911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__read_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf, 58011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize _Num, _CharT* __s, 58111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Delim __is_delim, 58211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __append_null, 58311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __is_getline) 58411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{ 58511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __n = 0; 58611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::iostate __status = 0; 58711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 58811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename basic_istream<_CharT, _Traits>::int_type int_type; 58911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The operations that can potentially throw are sbumpc, snextc, and sgetc. 59011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 59111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (;;) { 59211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n == _Num) { 59311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__is_getline) // didn't find delimiter as one of the _Num chars 59411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::failbit; 59511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 59611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 59711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int_type __c = __buf->sbumpc(); // sschwarz 59811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 59911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__that->_S_eof(__c)) { 60011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n < _Num || __is_getline) 60111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::eofbit; 60211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 60311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else if (__is_delim(_Traits::to_char_type(__c))) { 60411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__extract_delim) { // Extract and discard current character. 60511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__n; 60611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } else if ( !__pushback(__buf, _Traits::to_char_type(__c)) ) { // leave delimiter 60711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::failbit; 60811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 60911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 61011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 61111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // regular character 61211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *__s++ = _Traits::to_char_type(__c); 61311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__n; 61411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 61511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 61611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 61711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::badbit); 61811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT); 61911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n; 62011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 62111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__append_null) 62311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT); 62411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__status) 62511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__status); // This might throw. 62611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n; 62711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 62811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 62911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Much like __read_unbuffered, but with one additional function object: 63011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// __scan_delim(first, last) returns the first pointer p in [first, last) 63111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// such that __is_delim(p) is true. 63211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 63311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim> 63411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstreamsize _STLP_CALL 63511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__read_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __buf, 63611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize _Num, _CharT* __s, 63711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Delim __is_delim, _Scan_Delim __scan_delim, 63811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __append_null, 63911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __is_getline) { 64011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __n = 0; 64111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::iostate __status = 0; 64211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __done = false; 64311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 64411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 64511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) { 64611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __first = __buf->_M_gptr(); 64711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __last = __buf->_M_egptr(); 64811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //casting numeric_limits<ptrdiff_t>::max to streamsize only works is ptrdiff_t is signed or streamsize representation 64911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //is larger than ptrdiff_t one. 65011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_STATIC_ASSERT((sizeof(streamsize) > sizeof(ptrdiff_t)) || 65111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ((sizeof(streamsize) == sizeof(ptrdiff_t)) && numeric_limits<ptrdiff_t>::is_signed)) 65211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptrdiff_t __request = __STATIC_CAST(ptrdiff_t, (min) (__STATIC_CAST(streamsize, (numeric_limits<ptrdiff_t>::max)()), _Num - __n)); 65311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 65411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __p = __scan_delim(__first, __last); 65511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptrdiff_t __chunk = (min) (ptrdiff_t(__p - __first), __request); 65611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Traits::copy(__s, __first, __chunk); 65711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __s += __chunk; 65811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n += __chunk; 65911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump((int)__chunk); 66011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 66111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We terminated by finding delim. 66211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__p != __last && __p - __first <= __request) { 66311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__extract_delim) { 66411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n += 1; 66511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump(1); 66611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 66711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 66811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 66911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We terminated by reading all the characters we were asked for. 67111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__n == _Num) { 67211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 67311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Find out if we have reached eof. This matters for getline. 67411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__is_getline) { 67511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__chunk == __last - __first) { 67611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__that->_S_eof(__buf->sgetc())) 67711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::eofbit; 67811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 67911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 68011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::failbit; 68111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 68211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 68311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 68411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 68511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // The buffer contained fewer than _Num - __n characters. Either we're 68611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // at eof, or we should refill the buffer and try again. 68711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 68811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__that->_S_eof(__buf->sgetc())) { 68911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::eofbit; 69011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 69111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 69211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 69311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } // Close the while loop. 69411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 69511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 69611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::badbit); 69711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 69811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 69911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__done) { 70111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__append_null) 70211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert *__s = _STLP_DEFAULT_CONSTRUCTED(_CharT); 70311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__status != 0) 70411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__status); // This might throw. 70511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n; 70611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 70711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 70811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If execution has reached this point, then we have an empty buffer but 70911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // we have not reached eof. What that means is that the streambuf has 71011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // decided to switch from buffered to unbuffered input. We switch to 71111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // to __read_unbuffered. 71211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n + __read_unbuffered(__that, __buf, _Num - __n, __s, __is_delim, 71411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __extract_delim,__append_null,__is_getline); 71511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 71611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_STD_NAMESPACE 71811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 71911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 72011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 72111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::get(_CharT* __s, streamsize __n, 72211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _CharT __delim) { 72311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 72411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 72511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 72611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 72711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n > 0) { 72811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 72911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 73011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->egptr() != __buf->gptr()) 73111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 73211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __read_buffered(this, __buf, __n - 1, __s, 73311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_char_bound<_Traits>(__delim), 73411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Scan_for_char_val<_Traits>(__delim), 73511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, true, false); 73611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 73711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 73811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV __read_unbuffered(this, __buf, __n - 1, __s, 73911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_char_bound<_Traits>(__delim), 74011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, true, false); 74111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 74211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 74311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->_M_gcount == 0) 74511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 74611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 74711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 74811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 74911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Getline is essentially identical to get, except that it extracts 75111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the delimiter. 75211cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 75311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 75411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::getline(_CharT* __s, streamsize __n, 75511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _CharT __delim) { 75611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 75711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 75811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 75911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 76011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n > 0) { 76111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 76211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = __buf->egptr() != __buf->gptr() 76311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ? _STLP_PRIV __read_buffered(this, __buf, __n - 1, __s, 76411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_char_bound<_Traits>(__delim), 76511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Scan_for_char_val<_Traits>(__delim), 76611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert true, true, true) 76711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _STLP_PRIV __read_unbuffered(this, __buf, __n - 1, __s, 76811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_char_bound<_Traits>(__delim), 76911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert true, true, true); 77011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 77111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 77211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->_M_gcount == 0) 77411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 77511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 77711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 77811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 77911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Read n characters. We don't look for any delimiter, and we don't 78011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// put in a terminating null character. 78111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 78211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 78311cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) { 78411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 78511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 78611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 78711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry && !this->eof()) { 78811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>*__buf = this->rdbuf(); 78911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->gptr() != __buf->egptr()) 79011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount 79111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert = _STLP_PRIV __read_buffered(this, __buf, __n, __s, 79211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Constant_unary_fun<bool, int_type>(false), 79311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(), 79411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false, false); 79511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 79611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount 79711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert = _STLP_PRIV __read_unbuffered(this, __buf, __n, __s, 79811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Constant_unary_fun<bool, int_type>(false), 79911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false, false); 80011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 80111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 80211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 80311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->eof()) 80511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::eofbit | ios_base::failbit); 80611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 80711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 80811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 80911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Read n or fewer characters. We don't look for any delimiter, and 81211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// we don't put in a terminating null character. 81311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 81411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstreamsize 81511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __nmax) { 81611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 81711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 81811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 81911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry && !this->eof() && __nmax >= 0) { 82011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 82211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __avail = __buf->in_avail(); 82311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fbp : isn't full-blown setstate required here ? 82511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__avail == -1) 82611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_setstate_nothrow(ios_base::eofbit); 82711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 82811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__avail != 0) { 82911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 83011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->gptr() != __buf->egptr()) 83111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount 83211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert = _STLP_PRIV __read_buffered(this, __buf, (min) (__avail, __nmax), __s, 83311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Constant_unary_fun<bool, int_type>(false), 83411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(), 83511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false, false); 83611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 83711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount 83811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert = _STLP_PRIV __read_unbuffered(this, __buf, (min) (__avail, __nmax), __s, 83911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Constant_unary_fun<bool, int_type>(false), 84011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false, false); 84111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 84211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 84311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 84411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fbp : changed so that failbit is set only there, to pass Dietmar's test 84511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->eof()) 84611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::eofbit | ios_base::failbit); 84711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 84811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 84911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 85011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // if (this->eof()) 85211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // this->setstate(ios_base::eofbit | ios_base::failbit); 85311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return _M_gcount; 85511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 85611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 85711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 85811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid basic_istream<_CharT, _Traits>::_M_formatted_get(_CharT* __s) { 85911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this); // Skip whitespace. 86011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 86211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 86311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __nmax = this->width() > 0 86411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ? this->width() - 1 86511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : ((numeric_limits<streamsize>::max)() / sizeof(_CharT)) - 1; 86611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 86711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __n = __buf->gptr() != __buf->egptr() 86811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ? _STLP_PRIV __read_buffered(this, __buf, __nmax, __s, 86911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Is_wspace_null<_Traits>(this->_M_ctype_facet()), 87011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Scan_wspace_null<_Traits>(this->_M_ctype_facet()), 87111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, true, false) 87211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _STLP_PRIV __read_unbuffered(this, __buf, __nmax, __s, 87311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Is_wspace_null<_Traits>(this->_M_ctype_facet()), 87411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, true, false); 87511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n == 0) 87611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 87711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 87811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->width(0); 87911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 88011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A generic unbuffered function for ignoring characters. We stop 88211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// when we reach EOF, or when the function object __is_delim returns 88311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// true. In the last case, it extracts the character for which 88411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// __is_delim is true, if and only if __extract_delim is true. 88511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 88611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Is_Delim> 88711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid _STLP_CALL 88811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that, 88911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf, 89011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Delim __is_delim, 89111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __set_failbit) { 89211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __done = false; 89311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::iostate __status = 0; 89411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename basic_istream<_CharT, _Traits>::int_type int_type; 89511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 89611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 89711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (!__done) { 89811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int_type __c = __buf->sbumpc(); 89911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__that->_S_eof(__c)) { 90111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 90211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit 90311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : ios_base::eofbit; 90411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 90511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 90611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__is_delim(_Traits::to_char_type(__c))) { 90711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 90811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!__extract_delim) 90911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c)))) 91011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::failbit; 91111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 91511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::badbit); 91611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 91711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 91811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__status); 91911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 92011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// A generic buffered function for ignoring characters. Much like 92211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// _M_ignore_unbuffered, but with one additional function object: 92311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// __scan_delim(first, last) returns the first pointer p in [first, 92411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// last) such that __is_delim(p) is true. 92511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 92611cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim> 92711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid _STLP_CALL 92811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_M_ignore_buffered(basic_istream<_CharT, _Traits>* __that, 92911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf, 93011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Delim __is_delim, _Scan_Delim __scan_delim, 93111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __set_failbit) { 93211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __at_eof = false; 93311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __found_delim = false; 93411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 93511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 93611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (__buf->_M_egptr() != __buf->_M_gptr() && !__at_eof && !__found_delim) { 93711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr()); 93811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump((int)(__p - __buf->_M_gptr())); 93911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__p != __buf->_M_egptr()) { // We found delim, so we're done. 94111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__extract_delim) 94211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump(1); 94311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __found_delim = true; 94411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 94511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 94611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else // No delim. Try to refil the buffer. 94711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __at_eof = __that->_S_eof(__buf->sgetc()); 94811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } // Close the while loop. 94911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 95011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 95111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::badbit); 95211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return; 95311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 95411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 95511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__at_eof) { 95611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit 95711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : ios_base::eofbit); 95811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return; 95911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 96011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__found_delim) 96111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return; 96211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 96311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If execution has reached this point, then we have an empty buffer but 96411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // we have not reached eof. What that means is that the streambuf has 96511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // decided to switch from a buffered to an unbuffered mode. We switch 96611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // to _M_ignore_unbuffered. 96711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_ignore_unbuffered(__that, __buf, __is_delim, __extract_delim, __set_failbit); 96811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 96911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 97011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Overloaded versions of _M_ignore_unbuffered and _M_ignore_unbuffered 97111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// with an explicit count _Num. Return value is the number of 97211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// characters extracted. 97311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 97411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// The function object __max_chars takes two arguments, _Num and __n 97511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// (the latter being the number of characters we have already read), 97611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// and returns the maximum number of characters to read from the buffer. 97711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We parameterize _M_ignore_buffered so that we can use it for both 97811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// bounded and unbounded input; for the former the function object should 97911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// be minus<>, and for the latter it should return a constant maximum value. 98011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 98111cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim> 98211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstreamsize _STLP_CALL 98311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_M_ignore_unbuffered(basic_istream<_CharT, _Traits>* __that, 98411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf, 98511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize _Num, _Max_Chars __max_chars, 98611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Delim __is_delim, 98711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __set_failbit) { 98811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __n = 0; 98911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::iostate __status = 0; 99011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename basic_istream<_CharT, _Traits>::int_type int_type; 99111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 99311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (__max_chars(_Num, __n) > 0) { 99411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int_type __c = __buf->sbumpc(); 99511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 99611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__that->_S_eof(__c)) { 99711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= __set_failbit ? ios_base::eofbit | ios_base::failbit 99811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : ios_base::eofbit; 99911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 100011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 100111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__is_delim(_Traits::to_char_type(__c))) { 100311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__extract_delim) 100411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__n; 100511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__that->_S_eof(__buf->sputbackc(_Traits::to_char_type(__c)))) 100611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::failbit; 100711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 100811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 100911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 101011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fbp : added counter increment to pass Dietmar's test 101111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__n; 101211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 101311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 101411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 101511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::badbit); 101611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 101711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 101811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__status) 101911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__status); // This might throw. 102011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n; 102111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 102211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 102311cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Max_Chars, class _Is_Delim, class _Scan_Delim> 102411cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstreamsize _STLP_CALL 102511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_M_ignore_buffered(basic_istream<_CharT, _Traits>* __that, 102611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf, 102711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize _Num, 102811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Max_Chars __max_chars, 102911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Delim __is_delim, _Scan_Delim __scan_delim, 103011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __set_failbit) { 103111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __n = 0; 103211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __at_eof = false; 103311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __done = false; 103411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 103511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 103611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert while (__buf->_M_egptr() != __buf->_M_gptr() && !__done) { 103711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptrdiff_t __avail = __buf->_M_egptr() - __buf->_M_gptr(); 103811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __m = __max_chars(_Num, __n); 103911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__avail >= __m) { // We have more characters than we need. 104111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __last = __buf->_M_gptr() + __STATIC_CAST(ptrdiff_t, __m); 104211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __p = __scan_delim(__buf->_M_gptr(), __last); 104311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptrdiff_t __chunk = __p - __buf->_M_gptr(); 104411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n += __chunk; 104511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump((int)__chunk); 104611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 104711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__extract_delim && __p != __last) { 104811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n += 1; 104911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump(1); 105011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 105111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 105211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 105311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 105411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 105511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 105611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __p = __scan_delim(__buf->_M_gptr(), __buf->_M_egptr()); 105711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptrdiff_t __chunk = __p - __buf->_M_gptr(); 105811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n += __chunk; 105911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump((int)__chunk); 106011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__p != __buf->_M_egptr()) { // We found delim. 106211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__extract_delim) { 106311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n += 1; 106411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __buf->_M_gbump(1); 106511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 106611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 106711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 106811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 106911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 107011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // We didn't find delim. Try to refill the buffer. 107111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__that->_S_eof(__buf->sgetc())) { 107211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __done = true; 107311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __at_eof = true; 107411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 107511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 107611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } // Close the while loop. 107711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 107811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 107911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::badbit); 108011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n; 108111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 108211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__at_eof) 108411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__set_failbit ? ios_base::eofbit | ios_base::failbit 108511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : ios_base::eofbit); 108611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 108711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__done) 108811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n; 108911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If execution has reached this point, then we have an empty buffer but 109111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // we have not reached eof. What that means is that the streambuf has 109211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // decided to switch from buffered to unbuffered input. We switch to 109311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // to _M_ignore_unbuffered. 109411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __n + _M_ignore_unbuffered(__that, __buf, _Num, __max_chars, 109611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __is_delim, __extract_delim, __set_failbit); 109711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 109811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 109911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 110111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 110211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::ignore(streamsize __n) { 110311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 110411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 110511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 110611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 110711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 110811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _STLP_PRIV _Constant_unary_fun<bool, int_type> _Const_bool; 110911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize> _Const_streamsize; 111011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const streamsize __maxss = (numeric_limits<streamsize>::max)(); 111111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 111211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n == (numeric_limits<int>::max)()) { 111311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->gptr() != __buf->egptr()) 111411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_buffered(this, __buf, 111511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __maxss, _Const_streamsize(__maxss), 111611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Const_bool(false), 111711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(), 111811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false); 111911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 112011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_unbuffered(this, __buf, 112111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __maxss, _Const_streamsize(__maxss), 112211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Const_bool(false), false, false); 112311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 112411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 112511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->gptr() != __buf->egptr()) 112611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_buffered(this, __buf, 112711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n, minus<streamsize>(), 112811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Const_bool(false), 112911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(), 113011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false); 113111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 113211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_unbuffered(this, __buf, __n, minus<streamsize>(), 113311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Const_bool(false), false, false); 113411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 113511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 113611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 113711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 113811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 113911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 114111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 114211cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __delim) { 114311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 114411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 114511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 114611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 114711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 114811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef _STLP_PRIV _Constant_binary_fun<streamsize, streamsize, streamsize> 114911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Const_streamsize; 115011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const streamsize __maxss = (numeric_limits<streamsize>::max)(); 115111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 115211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n == (numeric_limits<int>::max)()) { 115311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->gptr() != __buf->egptr()) 115411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_buffered(this, __buf, 115511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __maxss, _Const_streamsize(__maxss), 115611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_int_bound<_Traits>(__delim), 115711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Scan_for_int_val<_Traits>(__delim), 115811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert true, false); 115911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 116011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_unbuffered(this, __buf, 116111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __maxss, _Const_streamsize(__maxss), 116211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_int_bound<_Traits>(__delim), 116311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert true, false); 116411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 116511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 116611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__buf->gptr() != __buf->egptr()) 116711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_buffered(this, __buf, 116811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n, minus<streamsize>(), 116911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_int_bound<_Traits>(__delim), 117011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Scan_for_int_val<_Traits>(__delim), 117111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert true, false); 117211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 117311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_gcount = _M_ignore_unbuffered(this, __buf, __n, minus<streamsize>(), 117411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_int_bound<_Traits>(__delim), 117511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert true, false); 117611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 117711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 117811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 117911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 118011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 118111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 118211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This member function does not construct a sentry object, because 118311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// it is called from sentry's constructor. 118411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 118511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertvoid basic_istream<_CharT, _Traits>::_M_skip_whitespace(bool __set_failbit) { 118611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __buf = this->rdbuf(); 118711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!__buf) 118811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::badbit); 118911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__buf->gptr() != __buf->egptr()) 119011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_ignore_buffered(this, __buf, 119111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()), 119211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Scan_for_not_wspace<_Traits>(this->_M_ctype_facet()), 119311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, __set_failbit); 119411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 119511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _M_ignore_unbuffered(this, __buf, 119611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Is_not_wspace<_Traits>(this->_M_ctype_facet()), 119711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, __set_failbit); 119811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 119911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// This is a very simple loop that reads characters from __src and puts 120211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// them into __dest. It looks complicated because of the (standard- 120311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// mandated) exception handling policy. 120411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// 120511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// We stop when we get an exception, when we fail to insert into the 120611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// output streambuf, or when __is_delim is true. 120711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 120811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_PRIV_NAMESPACE 120911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 121011cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Is_Delim> 121111cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstreamsize _STLP_CALL 121211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__copy_unbuffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src, 121311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __dest, 121411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Is_Delim __is_delim, 121511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __rethrow) { 121611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __extracted = 0; 121711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::iostate __status = 0; 121811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename basic_istream<_CharT, _Traits>::int_type int_type; 121911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int_type __c; 122011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 122111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 122211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (;;) { 122311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Get a character. If there's an exception, catch and (maybe) rethrow it. 122411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __c = __src->sbumpc(); 122511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 122611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If we failed to get a character, then quit. 122711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__that->_S_eof(__c)) { 122811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::eofbit; 122911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 123011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 123111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If it's the delimiter, then quit. 123211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__is_delim(_Traits::to_char_type(__c))) { 123311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!__extract_delim && !__pushback(__src, _Traits::to_char_type(__c))) 123411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::failbit; 123511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 123611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 123711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 123811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Try to put the character in the output streambuf. 123911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __failed = false; 124011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 124111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (!__that->_S_eof(__dest->sputc(_Traits::to_char_type(__c)))) 124211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ++__extracted; 124311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else 124411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __failed = true; 124511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 124611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 124711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __failed = true; 124811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 124911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 125011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // If we failed to put the character in the output streambuf, then 125111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // try to push it back to the input streambuf. 125211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__failed && !__pushback(__src, _Traits::to_char_type(__c))) 125311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::failbit; 125411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 125511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fbp : avoiding infinite loop in io-27-6-1-2-3.exp 125611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__failed) 125711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 125811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 125911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 126011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } /* for (;;) */ 126111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 126211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 126311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fbp : this try/catch moved here in reasonable assumption 126411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // __is_delim never throw (__pushback is guaranteed not to) 126511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 126611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // See 27.6.1.2.3, paragraph 13. 126711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__rethrow && __extracted == 0) 126811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::failbit); 126911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 127011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__status); 127111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __extracted; 127211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 127311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Buffered copying from one streambuf to another. We copy the characters 127511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// in chunks, rather than one at a time. We still have to worry about all 127611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// of the error conditions we checked in __copy_unbuffered, plus one more: 127711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// the streambuf might decide to switch from a buffered to an unbuffered mode. 127811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 127911cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate < class _CharT, class _Traits, class _Is_Delim, class _Scan_Delim> 128011cd02dfb91661c65134cac258cf5924270e9d2Dan Albertstreamsize _STLP_CALL 128111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert__copy_buffered(basic_istream<_CharT, _Traits>* __that, basic_streambuf<_CharT, _Traits>* __src, 128211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __dest, 128311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Scan_Delim __scan_delim, _Is_Delim __is_delim, 128411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __extract_delim, bool __rethrow) { 128511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __extracted = 0; 128611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ios_base::iostate __status = 0; 128711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename basic_istream<_CharT, _Traits>::int_type int_type; 128811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert //Borland compiler generates a warning if assignment because value is never used: 128911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert int_type __c /*= _Traits::eof()*/; 129011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _CharT* __first = __src->_M_gptr(); 129111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ptrdiff_t __avail = __src->_M_egptr() - __first; 129211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // fbp : introduced to move catch/try blocks out of the loop 129311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert bool __do_handle_exceptions = false; 129411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_TRY { 129611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert for (;;) { 129711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert const _CharT* __last = __scan_delim(__first, __src->_M_egptr()); 129811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 129911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Try to copy the entire input buffer to the output buffer. 130011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __n = __dest->sputn(__first, __extract_delim && __last != __src->_M_egptr() 130111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ? (__last - __first) + 1 130211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : (__last - __first)); 130311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __src->_M_gbump((int)__n); 130411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __extracted += __n; 130511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // from this on, catch() will call _M_handle_exceptions() 130711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __do_handle_exceptions = true; 130811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 130911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n < __avail) // We found the delimiter, or else failed to 131011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; // copy some characters. 131111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __c = __src->sgetc(); 131311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // Three possibilities: we succeeded in refilling the buffer, or 131511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // we got EOF, or the streambuf has switched to unbuffered mode. 131611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __first = __src->_M_gptr(); 131711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __avail = __src->_M_egptr() - __first; 131811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 131911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__avail > 0) 132011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert {} // dwa 1/16/00 -- suppress a Metrowerks warning 132111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else if (__that->_S_eof(__c)) { 132211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __status |= ios_base::eofbit; 132311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert break; 132411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 132511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert else { 132611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __extracted + __copy_unbuffered(__that, __src, __dest, __is_delim, 132711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __extract_delim, __rethrow); 132811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 132911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __do_handle_exceptions = false; 133111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 133211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 133311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 133411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_CATCH_ALL { 133511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert // See 27.6.1.2.3, paragraph 13. 133611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__rethrow && __do_handle_exceptions && __extracted == 0) 133711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->_M_handle_exception(ios_base::failbit); 133811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 133911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__status) 134111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __that->setstate(__status); // This might throw. 134211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return __extracted; 134311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 134411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_MOVE_TO_STD_NAMESPACE 134611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 134711cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 134811cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 134911cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits> 135011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::get(basic_streambuf<_CharT, _Traits>& __dest, _CharT __delim) { 135111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert sentry __sentry(*this, _No_Skip_WS()); 135211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = 0; 135311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 135511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __src = this->rdbuf(); 135611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 135711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__src) 135811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->_M_gcount = __src->egptr() != __src->gptr() 135911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ? _STLP_PRIV __copy_buffered(this, __src, &__dest, 136011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Scan_for_char_val<_Traits>(__delim), 136111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_char_bound<_Traits>(__delim), 136211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false) 136311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _STLP_PRIV __copy_unbuffered(this, __src, &__dest, 136411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Eq_char_bound<_Traits>(__delim), 136511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, false); 136611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 136711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 136811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (this->_M_gcount == 0) 136911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 137011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 137111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 137211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 137311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 137411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Copying characters into a streambuf. 137511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 137611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits>& 137711cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_istream<_CharT, _Traits> 137811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::operator>>(basic_streambuf<_CharT, _Traits>* __dest) { 137911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert streamsize __n = 0; 138011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert typedef typename basic_istream<_CharT, _Traits>::sentry _Sentry; 138111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _Sentry __sentry(*this); 138211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__sentry) { 138311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_streambuf<_CharT, _Traits>* __src = this->rdbuf(); 138411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__src && __dest) 138511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert __n = __src->egptr() != __src->gptr() 138611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ? _STLP_PRIV __copy_buffered(this, __src, __dest, 138711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Project2nd<const _CharT*, const _CharT*>(), 138811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Constant_unary_fun<bool, int_type>(false), 138911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, true) 139011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : _STLP_PRIV __copy_unbuffered(this, __src, __dest, 139111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert _STLP_PRIV _Constant_unary_fun<bool, int_type>(false), 139211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert false, true); 139311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert } 139411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert if (__n == 0) 139611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->setstate(ios_base::failbit); 139711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 139811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert return *this; 139911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 140011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ---------------------------------------------------------------- 140211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// basic_iostream<> class 140311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// ---------------------------------------------------------------- 140411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 140511cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 140611cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_iostream<_CharT, _Traits> 140711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert ::basic_iostream(basic_streambuf<_CharT, _Traits>* __buf) 140811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert : basic_ios<_CharT, _Traits>(), 140911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_istream<_CharT, _Traits>(__buf), 141011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert basic_ostream<_CharT, _Traits>(__buf) { 141111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert this->init(__buf); 141211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert} 141311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 141411cd02dfb91661c65134cac258cf5924270e9d2Dan Alberttemplate <class _CharT, class _Traits> 141511cd02dfb91661c65134cac258cf5924270e9d2Dan Albertbasic_iostream<_CharT, _Traits>::~basic_iostream() 141611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert{} 141711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 141811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert_STLP_END_NAMESPACE 141911cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142011cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#undef __BIS_int_type__ 142111cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#undef __BIS_pos_type__ 142211cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#undef __BIS_off_type__ 142311cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142411cd02dfb91661c65134cac258cf5924270e9d2Dan Albert#endif /* _STLP_ISTREAM_C */ 142511cd02dfb91661c65134cac258cf5924270e9d2Dan Albert 142611cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// Local Variables: 142711cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// mode:C++ 142811cd02dfb91661c65134cac258cf5924270e9d2Dan Albert// End: 1429