Istream C++ Source Code

#ifndef _ISTREAM_TCC
#define _ISTREAM_TCC 1
#pragma GCC system_header
#include <locale>
#include <ostream> // For flush()
namespace std
{
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>::sentry::
sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
{
ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
if (__in.good())
{
if (__in.tie())
__in.tie()->flush();
if (!__noskip && (__in.flags() & ios_base::skipws))
{
const __int_type __eof = traits_type::eof();
__streambuf_type* __sb = __in.rdbuf();
__int_type __c = __sb->sgetc();
const __ctype_type& __ct = __check_facet(__in._M_ctype);

while (!traits_type::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space,
traits_type::to_char_type(__c)))
__c = __sb->snextc();
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 195. Should basic_istream::sentry's constructor ever
// set eofbit?
if (traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
}
}
if (__in.good() && __err == ios_base::goodbit)

_M_ok = true;
else
{
__err |= ios_base::failbit;
__in.setstate(__err);
}
}

basic_istream<_CharT, _Traits>&
basic_istream<_CharT, _Traits>::
operator>>(__istream_type& (*__pf)(__istream_type&))
{ return __pf(*this); }

operator>>(__ios_type& (*__pf)(__ios_type&))
{
__pf(*this);
return *this;
}

operator>>(ios_base& (*__pf)(ios_base&))
{
__pf(*this);
return *this;
}

operator>>(bool& __n)
{
sentry __cerb(*this, false);
if (__cerb)
{
try
{
const __num_get_type& __ng = __check_facet(this->_M_num_get);
__ng.get(*this, 0, *this, __err, __n);
}
catch(...)
{ this->_M_setstate(ios_base::badbit); }
if (__err)
this->setstate(__err);
}
return *this;
}

operator>>(short& __n)
{
if (__cerb)
{
try
{
long __l;
__ng.get(*this, 0, *this, __err, __l);
// 118. basic_istream uses nonexistent num_get member functions.
if (!(__err & ios_base::failbit)
&& (numeric_limits<short>::min() <= __l
&& __l <= numeric_limits<short>::max()))
__n = __l;
else
}
catch(...)
if (__err)
}
return *this;
}

operator>>(unsigned short& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(int& __n)
{
if (__cerb)
{
try
{
long __l;
__ng.get(*this, 0, *this, __err, __l);
// 118. basic_istream uses nonexistent num_get member functions.
if (!(__err & ios_base::failbit)
&& (numeric_limits<int>::min() <= __l
&& __l <= numeric_limits<int>::max()))
__n = __l;
else
}
catch(...)
if (__err)
}
return *this;
}
operator>>(unsigned int& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(long& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(unsigned long& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}
#ifdef _GLIBCXX_USE_LONG_LONG
operator>>(long long& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(unsigned long long& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}
#endif

operator>>(float& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(double& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(long double& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(void*& __n)
{
if (__cerb)
{
try
{
}
catch(...)
if (__err)
}
return *this;
}

operator>>(__streambuf_type* __sbout)
{
if (__cerb && __sbout)
{
try
{
if (!__copy_streambufs(this->rdbuf(), __sbout))
}
catch(...)
{ this->_M_setstate(ios_base::failbit); }
}
else if (!__sbout)
if (__err)
return *this;
}

typename basic_istream<_CharT, _Traits>::int_type
get(void)
{
const int_type __eof = traits_type::eof();
int_type __c = __eof;
_M_gcount = 0;
sentry __cerb(*this, true);
if (__cerb)
{
try
{
__c = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
if (!traits_type::eq_int_type(__c, __eof))
_M_gcount = 1;
else
}
catch(...)
}
if (!_M_gcount)
if (__err)
return __c;
}

get(char_type& __c)
{
_M_gcount = 0;
if (__cerb)
{
try
{
const int_type __cb = this->rdbuf()->sbumpc();
// 27.6.1.1 paragraph 3
if (!traits_type::eq_int_type(__cb, traits_type::eof()))
{
_M_gcount = 1;
__c = traits_type::to_char_type(__cb);
}
else
}
catch(...)
}
if (!_M_gcount)
if (__err)
return *this;
}

get(char_type* __s, streamsize __n, char_type __delim)
{
_M_gcount = 0;
if (__cerb)
{
try
{
const int_type __idelim = traits_type::to_int_type(__delim);
__streambuf_type* __sb = this->rdbuf();
int_type __c = __sb->sgetc();
while (_M_gcount + 1 < __n

&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim))
{
*__s++ = traits_type::to_char_type(__c);
++_M_gcount;
}
}
catch(...)
}
*__s = char_type();
if (!_M_gcount)
if (__err)
return *this;
}

get(__streambuf_type& __sb, char_type __delim)
{
_M_gcount = 0;
if (__cerb)
{
try
{
__streambuf_type* __this_sb = this->rdbuf();
int_type __c = __this_sb->sgetc();
char_type __c2 = traits_type::to_char_type(__c);
while (!traits_type::eq_int_type(__c, __eof)

&& !traits_type::eq_int_type(__c, __idelim)
&& !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
{
++_M_gcount;
__c = __this_sb->snextc();
__c2 = traits_type::to_char_type(__c);
}
}
catch(...)
}
if (!_M_gcount)
if (__err)
return *this;
}

getline(char_type* __s, streamsize __n, char_type __delim)
{
_M_gcount = 0;
if (__cerb)
{
try
{
while (_M_gcount + 1 < __n

&& !traits_type::eq_int_type(__c, __eof)
&& !traits_type::eq_int_type(__c, __idelim))
{
streamsize __size = std::min(streamsize(__sb->egptr()
- __sb->gptr()),
__n - _M_gcount - 1);
if (__size > 1)
{
const char_type* __p = traits_type::find(__sb->gptr(),
__size,
__delim);
if (__p)
__size = __p - __sb->gptr();
traits_type::copy(__s, __sb->gptr(), __size);
__s += __size;
__sb->gbump(__size);
_M_gcount += __size;
__c = __sb->sgetc();
}
else
{
*__s++ = traits_type::to_char_type(__c);
++_M_gcount;
}
}
else if (traits_type::eq_int_type(__c, __idelim))
{
++_M_gcount;
__sb->sbumpc();
}
else
}
catch(...)
}
*__s = char_type();
if (!_M_gcount)
if (__err)
return *this;
}

ignore(streamsize __n, int_type __delim)
{
_M_gcount = 0;
if (__cerb && __n > 0)
{
try
{
int_type __c;
if (__n != numeric_limits<streamsize>::max())
--__n;
while (_M_gcount <= __n
&& !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
{
++_M_gcount;
if (traits_type::eq_int_type(__c, __delim))
break;
}
}
catch(...)
if (__err)
}
return *this;
}

typename basic_istream<_CharT, _Traits>::int_type
peek(void)
{
int_type __c = traits_type::eof();
_M_gcount = 0;
if (__cerb)
{
try
{
__c = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(__c, traits_type::eof()))
}
catch(...)
if (__err)
}
return __c;
}

read(char_type* __s, streamsize __n)
{
_M_gcount = 0;
if (__cerb)
{
try
{
_M_gcount = this->rdbuf()->sgetn(__s, __n);
if (_M_gcount != __n)
__err |= (ios_base::eofbit | ios_base::failbit);
}
catch(...)
if (__err)
}
return *this;
}

streamsize
readsome(char_type* __s, streamsize __n)
{
_M_gcount = 0;
if (__cerb)
{
try
{
// Cannot compare int_type with streamsize generically.
const streamsize __num = this->rdbuf()->in_avail();
if (__num > 0)
_M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
else if (__num == -1)
}
catch(...)
if (__err)
}
return _M_gcount;
}

putback(char_type __c)
{
// 60. What is a formatted input function?
_M_gcount = 0;
if (__cerb)
{
try
{
if (!__sb
|| traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
__err |= ios_base::badbit;
}
catch(...)
if (__err)
}
return *this;
}

unget(void)
{
// 60. What is a formatted input function?
_M_gcount = 0;
if (__cerb)
{
try
{
if (!__sb
|| traits_type::eq_int_type(__sb->sungetc(), __eof))
}
catch(...)
if (__err)
}
return *this;
}

int
sync(void)
{
// DR60. Do not change _M_gcount.
int __ret = -1;
if (__cerb)
{
try
{
if (__sb)
{
if (__sb->pubsync() == -1)
else
__ret = 0;
}
}
catch(...)
if (__err)
}
return __ret;
}

typename basic_istream<_CharT, _Traits>::pos_type
tellg(void)
{
pos_type __ret = pos_type(-1);
try
{
if (!this->fail())
__ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
}
catch(...)
return __ret;
}
seekg(pos_type __pos)
{
try
{
if (!this->fail())
{
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekpos(__pos,
ios_base::in);
// 129. Need error indication from seekp() and seekg()

if (__p == pos_type(off_type(-1)))
}
}
catch(...)
if (__err)
return *this;
}

seekg(off_type __off, ios_base::seekdir __dir)
{
try
{
if (!this->fail())
{
// 136. seekp, seekg setting wrong streams?
const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
ios_base::in);
// 129. Need error indication from seekp() and seekg()

if (__p == pos_type(off_type(-1)))
}
}
catch(...)
if (__err)
return *this;
}
// 27.6.1.2.3 Character extraction templates

operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::int_type __int_type;
typename __istream_type::sentry __cerb(__in, false);

if (__cerb)
{
try
{
const __int_type __cb = __in.rdbuf()->sbumpc();
if (!_Traits::eq_int_type(__cb, _Traits::eof()))
__c = _Traits::to_char_type(__cb);
else
__err |= (ios_base::eofbit | ios_base::failbit);
}
catch(...)
{ __in._M_setstate(ios_base::badbit); }
if (__err)
}
return __in;
}

operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
{
typedef typename __istream_type::__streambuf_type __streambuf_type;
typedef typename _Traits::int_type int_type;
typedef _CharT char_type;
typedef ctype<_CharT> __ctype_type;
streamsize __extracted = 0;
if (__cerb)
{
try
{
// Figure out how many characters to extract.
streamsize __num = __in.width();
if (__num <= 0)
__num = numeric_limits<streamsize>::max();
const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
const int_type __eof = _Traits::eof();

while (__extracted < __num - 1

&& !_Traits::eq_int_type(__c, __eof)
&& !__ct.is(ctype_base::space,
_Traits::to_char_type(__c)))
{
*__s++ = _Traits::to_char_type(__c);
++__extracted;
}
if (_Traits::eq_int_type(__c, __eof))
// 68. Extractors for char* should store null at end
*__s = char_type();
__in.width(0);
}
catch(...)
{ __in._M_setstate(ios_base::badbit); }
}
if (!__extracted)
if (__err)
return __in;
}
// 27.6.1.4 Standard basic_istream manipulators

basic_istream<_CharT,_Traits>&
ws(basic_istream<_CharT,_Traits>& __in)
{
typedef typename __istream_type::__ctype_type __ctype_type;

const __int_type __eof = _Traits::eof();
while (!_Traits::eq_int_type(__c, __eof)

&& __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
__in.setstate(ios_base::eofbit);
return __in;
}
// 21.3.7.9 basic_string::getline and operators

template<typename _CharT, typename _Traits, typename _Alloc>
operator>>(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__size_type __extracted = 0;
if (__cerb)
{
try
{
// Avoid reallocation for common case.
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
const streamsize __w = __in.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
while (__extracted < __n

&& !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
{
if (__len == sizeof(__buf) / sizeof(_CharT))
{
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
}
__str.append(__buf, __len);
__in.width(0);
}
catch(...)
{
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
__in._M_setstate(ios_base::badbit);
}
}
// 211. operator>>(istream&, string&) doesn't set failbit
if (!__extracted)
if (__err)
return __in;
}
template<typename _CharT, typename _Traits, typename _Alloc>

getline(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{
typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
typedef typename __string_type::size_type __size_type;
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __istream_type::sentry __cerb(__in, true);
if (__cerb)
{
try
{
// Avoid reallocation for common case.
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
const __int_type __idelim = _Traits::to_int_type(__delim);
while (__extracted < __n

&& !_Traits::eq_int_type(__c, __idelim))
{
if (__len == sizeof(__buf) / sizeof(_CharT))
{
__str.append(__buf, sizeof(__buf) / sizeof(_CharT));
__len = 0;
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
}
__str.append(__buf, __len);
else if (_Traits::eq_int_type(__c, __idelim))
{
++__extracted;
__sb->sbumpc();
}
else
}
catch(...)
{
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
__in._M_setstate(ios_base::badbit);
}
}
if (!__extracted)
if (__err)
return __in;
}
template<class _CharT, class _Traits, class _Alloc>

inline basic_istream<_CharT,_Traits>&
getline(basic_istream<_CharT, _Traits>& __in,
basic_string<_CharT,_Traits,_Alloc>& __str)
{ return getline(__in, __str, __in.widen('\n')); }
// Inhibit implicit instantiations for required instantiations,

// which are defined via explicit instantiations elsewhere.
// NB: This syntax is a GNU extension.
#if _GLIBCXX_EXTERN_TEMPLATE
extern template class basic_istream<char>;
extern template istream& ws(istream&);
extern template istream& operator>>(istream&, char&);
extern template istream& operator>>(istream&, char*);
extern template istream& operator>>(istream&, unsigned char&);
extern template istream& operator>>(istream&, signed char&);
extern template istream& operator>>(istream&, unsigned char*);
extern template istream& operator>>(istream&, signed char*);
extern template class basic_iostream<char>;
#ifdef _GLIBCXX_USE_WCHAR_T
extern template class basic_istream<wchar_t>;
extern template wistream& ws(wistream&);
extern template wistream& operator>>(wistream&, wchar_t&);
extern template wistream& operator>>(wistream&, wchar_t*);
extern template class basic_iostream<wchar_t>;

#endif
#endif
} // namespace std
#endif

Istream C++ Source Code

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Istream C++ Source Code

Uploaded by

Copyright:

Available Formats

#ifndef _ISTREAM_TCC

#pragma GCC system_header

const __ctype_type& __ct = __check_facet(__in._M_ctype);

if (__in.good() && __err == ios_base::goodbit)

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

while (_M_gcount + 1 < __n

template<typename _CharT, typename _Traits>

while (!traits_type::eq_int_type(__c, __eof)

template<typename _CharT, typename _Traits>

while (_M_gcount + 1 < __n

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

template<typename _CharT, typename _Traits>

// 129. Need error indication from seekp() and seekg()

template<typename _CharT, typename _Traits>

// 129. Need error indication from seekp() and seekg()

// 27.6.1.2.3 Character extraction templates

typename __istream_type::sentry __cerb(__in, false);

template<typename _CharT, typename _Traits>

const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

const int_type __eof = _Traits::eof();

while (__extracted < __num - 1

// 27.6.1.4 Standard basic_istream manipulators

const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

while (!_Traits::eq_int_type(__c, __eof)

// 21.3.7.9 basic_string::getline and operators

while (__extracted < __n

template<typename _CharT, typename _Traits, typename _Alloc>

while (__extracted < __n

template<class _CharT, class _Traits, class _Alloc>

// Inhibit implicit instantiations for required instantiations,

extern template class basic_iostream<char>;

extern template class basic_iostream<wchar_t>;

You might also like

const __ctype_type& ct = check_facet(__in._M_ctype);

if (in.good() && err == ios_base::goodbit)

while (!traits_type::eq_int_type(c, eof)

typename __istream_type::sentry cerb(in, false);

while (extracted < num - 1

while (!_Traits::eq_int_type(c, eof)

while (extracted < n

while (extracted < n