STL/stl/inc/istream

925 строки
33 KiB
C++

// istream standard header
// Copyright (c) Microsoft Corporation.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#pragma once
#ifndef _ISTREAM_
#define _ISTREAM_
#include <yvals_core.h>
#if _STL_COMPILER_PREPROCESSOR
#include <ostream>
#pragma pack(push, _CRT_PACKING)
#pragma warning(push, _STL_WARNING_LEVEL)
#pragma warning(disable : _STL_DISABLED_WARNINGS)
_STL_DISABLE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new
_STD_BEGIN
#pragma vtordisp(push, 2) // compiler bug workaround
// CLASS TEMPLATE basic_istream
template <class _Elem, class _Traits>
class basic_istream : virtual public basic_ios<_Elem, _Traits> { // control extractions from a stream buffer
public:
using _Myios = basic_ios<_Elem, _Traits>;
using _Mysb = basic_streambuf<_Elem, _Traits>;
using _Iter = istreambuf_iterator<_Elem, _Traits>;
using _Ctype = ctype<_Elem>;
using _Nget = num_get<_Elem, _Iter>;
#if defined(__FORCE_INSTANCE)
explicit __CLR_OR_THIS_CALL basic_istream(_Mysb* _Strbuf, bool _Isstd, bool _Skip_init) : _Chcount(0) {
if (!_Skip_init) {
_Myios::init(_Strbuf, _Isstd);
}
}
#endif // defined(__FORCE_INSTANCE)
explicit __CLR_OR_THIS_CALL basic_istream(_Mysb* _Strbuf, bool _Isstd = false)
: _Chcount(0) {
_Myios::init(_Strbuf, _Isstd);
}
__CLR_OR_THIS_CALL basic_istream(_Uninitialized) {
this->_Addstd(this);
}
protected:
__CLR_OR_THIS_CALL basic_istream(basic_istream&& _Right) : _Chcount(_Right._Chcount) {
_Myios::init();
_Myios::move(_STD move(_Right));
_Right._Chcount = 0;
}
basic_istream& __CLR_OR_THIS_CALL operator=(basic_istream&& _Right) {
this->swap(_Right);
return *this;
}
void __CLR_OR_THIS_CALL swap(basic_istream& _Right) {
_Myios::swap(_Right);
_STD swap(_Chcount, _Right._Chcount);
}
public:
__CLR_OR_THIS_CALL basic_istream(const basic_istream&) = delete;
basic_istream& __CLR_OR_THIS_CALL operator=(const basic_istream&) = delete;
virtual __CLR_OR_THIS_CALL ~basic_istream() noexcept {}
using int_type = typename _Traits::int_type;
using pos_type = typename _Traits::pos_type;
using off_type = typename _Traits::off_type;
// CLASS TEMPLATE sentry
class _Sentry_base {
public:
__CLR_OR_THIS_CALL _Sentry_base(basic_istream& _Istr) : _Myistr(_Istr) {
const auto _Rdbuf = _Myistr.rdbuf();
if (_Rdbuf) {
_Rdbuf->_Lock();
}
}
__CLR_OR_THIS_CALL ~_Sentry_base() noexcept {
const auto _Rdbuf = _Myistr.rdbuf();
if (_Rdbuf) {
_Rdbuf->_Unlock();
}
}
basic_istream& _Myistr;
_Sentry_base& operator=(const _Sentry_base&) = delete;
};
class sentry : public _Sentry_base {
public:
explicit __CLR_OR_THIS_CALL sentry(basic_istream& _Istr, bool _Noskip = false)
: _Sentry_base(_Istr), _Ok(_Sentry_base::_Myistr._Ipfx(_Noskip)) {}
explicit __CLR_OR_THIS_CALL operator bool() const {
return _Ok;
}
__CLR_OR_THIS_CALL sentry(const sentry&) = delete;
sentry& __CLR_OR_THIS_CALL operator=(const sentry&) = delete;
private:
bool _Ok; // true if _Ipfx succeeded at construction
};
bool __CLR_OR_THIS_CALL _Ipfx(bool _Noskip = false) { // test stream state and skip whitespace as needed
if (!this->good()) {
_Myios::setstate(ios_base::failbit);
return false;
}
// state okay, flush tied stream and skip whitespace
const auto _Tied = _Myios::tie();
if (_Tied) {
_Tied->flush();
}
bool _Eof = false;
if (!_Noskip && this->flags() & ios_base::skipws) { // skip whitespace
const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(this->getloc());
_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();
for (;; _Meta = _Myios::rdbuf()->snextc()) {
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
_Eof = true;
break;
} else if (!_Ctype_fac.is(_Ctype::space, _Traits::to_char_type(_Meta))) {
break; // not whitespace, quit
}
}
_CATCH_IO_END
}
if (_Eof) {
_Myios::setstate(ios_base::eofbit | ios_base::failbit);
}
return this->good();
}
// TRANSITION, ABI: non-Standard ipfx() is preserved for binary compatibility
bool __CLR_OR_THIS_CALL ipfx(bool _Noskip = false) { // test stream state and skip whitespace as needed
return _Ipfx(_Noskip);
}
// TRANSITION, ABI: non-Standard isfx() is preserved for binary compatibility
void __CLR_OR_THIS_CALL isfx() {} // perform any wrapup
#ifdef _M_CEE_PURE
basic_istream& __CLR_OR_THIS_CALL operator>>(basic_istream&(__clrcall* _Pfn)(basic_istream&) ) {
// call basic_istream manipulator
return _Pfn(*this);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(_Myios&(__clrcall* _Pfn)(_Myios&) ) { // call basic_ios manipulator
_Pfn(*this);
return *this;
}
basic_istream& __CLR_OR_THIS_CALL operator>>(ios_base&(__clrcall* _Pfn)(ios_base&) ) { // call ios_base manipulator
_Pfn(*this);
return *this;
}
#endif // _M_CEE_PURE
basic_istream& __CLR_OR_THIS_CALL operator>>(basic_istream&(__cdecl* _Pfn)(basic_istream&) ) {
// call basic_istream manipulator
return _Pfn(*this);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(_Myios&(__cdecl* _Pfn)(_Myios&) ) { // call basic_ios manipulator
_Pfn(*this);
return *this;
}
basic_istream& __CLR_OR_THIS_CALL operator>>(ios_base&(__cdecl* _Pfn)(ios_base&) ) { // call ios_base manipulator
_Pfn(*this);
return *this;
}
private:
template <class _Ty>
basic_istream& _Common_extract_with_num_get(_Ty& _Val) { // formatted extract with num_get
ios_base::iostate _Err = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok) { // state okay, use facet to extract
_TRY_IO_BEGIN
_STD use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Val);
_CATCH_IO_END
}
_Myios::setstate(_Err);
return *this;
}
template <class = void>
void _Increment_gcount() {
if (_Chcount != (numeric_limits<streamsize>::max) ()) {
++_Chcount;
}
}
public:
basic_istream& __CLR_OR_THIS_CALL operator>>(bool& _Val) { // extract a boolean
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(short& _Val) { // extract a short
ios_base::iostate _Err = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok) { // state okay, use facet to extract
_TRY_IO_BEGIN
long _Lval;
_STD use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Lval);
if (_Lval < SHRT_MIN) {
_Err |= ios_base::failbit;
_Val = SHRT_MIN;
} else if (_Lval > SHRT_MAX) {
_Err |= ios_base::failbit;
_Val = SHRT_MAX;
} else {
_Val = static_cast<short>(_Lval);
}
_CATCH_IO_END
}
_Myios::setstate(_Err);
return *this;
}
// NOTE:
// If you are not using native wchar_t, the unsigned short extractor
// is masked by an explicit specialization that treats an unsigned
// short as a wide character.
// To read or write unsigned shorts as integers with wchar_t streams,
// make wchar_t a native type with the command line option /Zc:wchar_t.
basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned short& _Val) { // extract an unsigned short
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(int& _Val) { // extract an int
static_assert(sizeof(int) == sizeof(long), "Bad overflow assumptions due to sizeof(int) != sizeof(long)");
long _Result = _Val;
_Common_extract_with_num_get(_Result);
_Val = _Result;
return *this;
}
basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned int& _Val) { // extract an unsigned int
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(long& _Val) { // extract a long
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned long& _Val) { // extract an unsigned long
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(long long& _Val) { // extract a long long
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(unsigned long long& _Val) { // extract an unsigned long long
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(float& _Val) { // extract a float
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(double& _Val) { // extract a double
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(long double& _Val) { // extract a long double
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(void*& _Val) { // extract a void pointer
return _Common_extract_with_num_get(_Val);
}
basic_istream& __CLR_OR_THIS_CALL operator>>(_Mysb* _Strbuf) { // extract until end-of-file into a stream buffer
_Chcount = 0; // behaves as an unformatted input function
const sentry _Ok(*this, true);
ios_base::iostate _State = ios_base::goodbit;
if (_Ok && _Strbuf) { // state okay, extract characters
_TRY_IO_BEGIN
for (int_type _Meta = _Myios::rdbuf()->sgetc();; _Meta = _Myios::rdbuf()->snextc()) {
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
_State |= ios_base::eofbit;
break;
}
// got a character, insert it into buffer
_TRY_BEGIN
if (_Traits::eq_int_type(_Traits::eof(), _Strbuf->sputc(_Traits::to_char_type(_Meta)))) {
break;
}
_CATCH_ALL
break;
_CATCH_END
_Increment_gcount();
}
_CATCH_IO_END
}
if (_Chcount == 0) { // If the function inserts no characters, it calls setstate(failbit)
_State |= ios_base::failbit;
}
_Myios::setstate(_State);
return *this;
}
int_type __CLR_OR_THIS_CALL get() { // extract a metacharacter
int_type _Meta = 0;
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (!_Ok) {
_Meta = _Traits::eof(); // state not okay, return EOF
} else { // state okay, extract a character
_TRY_IO_BEGIN
_Meta = _Myios::rdbuf()->sgetc();
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
_State |= ios_base::eofbit | ios_base::failbit; // end of file
} else { // got a character, count it
_Myios::rdbuf()->sbumpc();
_Chcount = 1;
}
_CATCH_IO_END
}
_Myios::setstate(_State);
return _Meta;
}
basic_istream& __CLR_OR_THIS_CALL get(_Elem* _Str, streamsize _Count) { // get up to _Count characters into NTCS
return get(_Str, _Count, _Myios::widen('\n'));
}
basic_istream& __CLR_OR_THIS_CALL get(
_Elem* _Str, streamsize _Count, _Elem _Delim) { // get up to _Count characters into NTCS, stop before _Delim
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok && 0 < _Count) { // state okay, extract characters
_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();
for (; 0 < --_Count; _Meta = _Myios::rdbuf()->snextc()) {
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
_State |= ios_base::eofbit;
break;
} else if (_Traits::to_char_type(_Meta) == _Delim) {
break; // got a delimiter, quit
} else { // got a character, add it to string
*_Str++ = _Traits::to_char_type(_Meta);
_Increment_gcount();
}
}
_CATCH_IO_END
}
_Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
*_Str = _Elem(); // add terminating null character
return *this;
}
basic_istream& __CLR_OR_THIS_CALL get(_Elem& _Ch) { // get a character
int_type _Meta = get();
if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
_Ch = _Traits::to_char_type(_Meta);
}
return *this;
}
basic_istream& __CLR_OR_THIS_CALL get(_Mysb& _Strbuf) { // extract up to newline and insert into stream buffer
return get(_Strbuf, _Myios::widen('\n'));
}
basic_istream& __CLR_OR_THIS_CALL get(
_Mysb& _Strbuf, _Elem _Delim) { // extract up to delimiter and insert into stream buffer
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok) { // state okay, use facet to extract
_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();
for (;; _Meta = _Myios::rdbuf()->snextc()) {
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
_State |= ios_base::eofbit;
break;
} else { // got a character, insert it into stream buffer
_TRY_BEGIN
_Elem _Ch = _Traits::to_char_type(_Meta);
if (_Ch == _Delim || _Traits::eq_int_type(_Traits::eof(), _Strbuf.sputc(_Ch))) {
break;
}
_CATCH_ALL
break;
_CATCH_END
_Increment_gcount();
}
}
_CATCH_IO_END
}
if (_Chcount == 0) {
_State |= ios_base::failbit;
}
_Myios::setstate(_State);
return *this;
}
basic_istream& __CLR_OR_THIS_CALL getline(
_Elem* _Str, streamsize _Count) { // get up to _Count characters into NTCS, discard newline
return getline(_Str, _Count, _Myios::widen('\n'));
}
basic_istream& __CLR_OR_THIS_CALL getline(
_Elem* _Str, streamsize _Count, _Elem _Delim) { // get up to _Count characters into NTCS, discard _Delim
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok && 0 < _Count) { // state okay, use facet to extract
int_type _Metadelim = _Traits::to_int_type(_Delim);
_TRY_IO_BEGIN
int_type _Meta = _Myios::rdbuf()->sgetc();
for (;; _Meta = _Myios::rdbuf()->snextc()) {
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
_State |= ios_base::eofbit;
break;
} else if (_Meta == _Metadelim) { // got a delimiter, discard it and quit
_Increment_gcount();
_Myios::rdbuf()->sbumpc();
break;
} else if (--_Count <= 0) { // buffer full, quit
_State |= ios_base::failbit;
break;
} else { // got a character, add it to string
*_Str++ = _Traits::to_char_type(_Meta);
_Increment_gcount();
}
}
_CATCH_IO_END
}
*_Str = _Elem(); // add terminating null character
_Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
return *this;
}
basic_istream& __CLR_OR_THIS_CALL ignore(streamsize _Count = 1,
int_type _Metadelim = _Traits::eof()) { // ignore up to _Count characters, discarding delimiter
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok && 0 < _Count) { // state okay, use facet to extract
_TRY_IO_BEGIN
for (;;) { // get a metacharacter if more room in buffer
int_type _Meta;
if (_Count != (numeric_limits<streamsize>::max) () && --_Count < 0) {
break; // buffer full, quit
} else if (_Traits::eq_int_type(_Traits::eof(),
_Meta = _Myios::rdbuf()->sbumpc())) { // end of file, quit
_State |= ios_base::eofbit;
break;
} else { // got a character, count it
_Increment_gcount();
if (_Meta == _Metadelim) {
break; // got a delimiter, quit
}
}
}
_CATCH_IO_END
}
_Myios::setstate(_State);
return *this;
}
basic_istream& __CLR_OR_THIS_CALL read(_Elem* _Str, streamsize _Count) { // read up to _Count characters into buffer
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok && 0 < _Count) { // state okay, use facet to extract
_TRY_IO_BEGIN
const streamsize _Num = _Myios::rdbuf()->sgetn(_Str, _Count);
_Chcount = _Num;
if (_Num != _Count) {
_State |= ios_base::eofbit | ios_base::failbit; // short read
}
_CATCH_IO_END
}
_Myios::setstate(_State);
return *this;
}
streamsize __CLR_OR_THIS_CALL readsome(_Elem* _Str,
streamsize _Count) { // read up to _Count characters into buffer, without blocking
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
streamsize _Num;
if (!_Ok) {
_State |= ios_base::failbit; // no buffer, fail
} else if ((_Num = _Myios::rdbuf()->in_avail()) < 0) {
_State |= ios_base::eofbit; // no characters available
} else if (0 < _Count && 0 < _Num) { // read available
read(_Str, _Num < _Count ? _Num : _Count);
}
_Myios::setstate(_State);
return gcount();
}
int_type __CLR_OR_THIS_CALL peek() {
ios_base::iostate _State = ios_base::goodbit;
_Chcount = 0;
int_type _Meta = 0;
const sentry _Ok(*this, true);
if (!_Ok) {
_Meta = _Traits::eof(); // state not okay, return EOF
} else { // state okay, read a character
_TRY_IO_BEGIN
if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Myios::rdbuf()->sgetc())) {
_State |= ios_base::eofbit;
}
_CATCH_IO_END
}
_Myios::setstate(_State);
return _Meta;
}
basic_istream& __CLR_OR_THIS_CALL putback(_Elem _Ch) { // put back a character
_Chcount = 0;
ios_base::iostate _State = ios_base::goodbit;
ios_base::iostate _Oldstate = _Myios::rdstate();
_Myios::clear(_Oldstate & ~ios_base::eofbit);
const sentry _Ok(*this, true);
if (_Ok) { // state okay, put character back
_TRY_IO_BEGIN
if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sputbackc(_Ch))) {
_State |= ios_base::badbit | _Oldstate;
}
_CATCH_IO_END
}
_Myios::setstate(_State);
return *this;
}
basic_istream& __CLR_OR_THIS_CALL unget() { // put back last read character
_Chcount = 0;
ios_base::iostate _State = ios_base::goodbit;
ios_base::iostate _Oldstate = _Myios::rdstate();
_Myios::clear(_Oldstate & ~ios_base::eofbit);
const sentry _Ok(*this, true);
if (_Ok) { // state okay, put character back
_TRY_IO_BEGIN
if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sungetc())) {
_State |= ios_base::badbit | _Oldstate;
}
_CATCH_IO_END
}
_Myios::setstate(_State);
return *this;
}
_NODISCARD streamsize __CLR_OR_THIS_CALL gcount() const { // get count from last extraction
return _Chcount;
}
int __CLR_OR_THIS_CALL sync() { // synchronize with input source
const sentry _Ok(*this, true);
const auto _Rdbuf = _Myios::rdbuf();
if (!_Rdbuf) {
return -1;
}
bool _Sync_failed = true; // sync fails if an exception is thrown
_TRY_IO_BEGIN
_Sync_failed = _Rdbuf->pubsync() == -1;
_CATCH_IO_END
if (_Sync_failed) {
_Myios::setstate(ios_base::badbit);
return -1;
}
return 0;
}
basic_istream& __CLR_OR_THIS_CALL seekg(pos_type _Pos) { // set input stream position to _Pos
ios_base::iostate _State = ios_base::goodbit;
ios_base::iostate _Oldstate = _Myios::rdstate();
_Myios::clear(_Oldstate & ~ios_base::eofbit);
const sentry _Ok(*this, true);
if (!this->fail() && static_cast<off_type>(_Myios::rdbuf()->pubseekpos(_Pos, ios_base::in)) == -1) {
_Myios::setstate(_State | ios_base::failbit);
}
return *this;
}
basic_istream& __CLR_OR_THIS_CALL seekg(
off_type _Off, ios_base::seekdir _Way) { // change input stream position by _Off, according to _Way
ios_base::iostate _State = ios_base::goodbit;
ios_base::iostate _Oldstate = _Myios::rdstate();
_Myios::clear(_Oldstate & ~ios_base::eofbit);
const sentry _Ok(*this, true);
if (!this->fail() && static_cast<off_type>(_Myios::rdbuf()->pubseekoff(_Off, _Way, ios_base::in)) == -1) {
_Myios::setstate(_State | ios_base::failbit);
}
return *this;
}
pos_type __CLR_OR_THIS_CALL tellg() {
const sentry _Ok(*this, true);
if (!this->fail()) {
return _Myios::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
} else {
return pos_type(-1);
}
}
private:
streamsize _Chcount; // the character count
};
#pragma vtordisp(pop) // compiler bug workaround
#ifndef _NATIVE_WCHAR_T_DEFINED
template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch);
// NOTE:
// If you are not using native wchar_t, the following explicit
// specialization will mask the member function (above) that treats
// an unsigned short as an integer.
// To read or write unsigned shorts as integers with wchar_t streams,
// make wchar_t a native type with the command line option /Zc:wchar_t.
template <>
inline basic_istream<unsigned short, char_traits<unsigned short>>& __CLR_OR_THIS_CALL basic_istream<unsigned short,
char_traits<unsigned short>>::operator>>(unsigned short& _Ch) { // extract a character
return _STD operator>>(*this, _Ch);
}
#endif // _NATIVE_WCHAR_T_DEFINED
#if defined(_DLL_CPPLIB)
#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
template class _CRTIMP2_PURE_IMPORT basic_istream<char, char_traits<char>>;
template class _CRTIMP2_PURE_IMPORT basic_istream<wchar_t, char_traits<wchar_t>>;
#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
#ifdef __FORCE_INSTANCE
template class _CRTIMP2_PURE_IMPORT basic_istream<unsigned short, char_traits<unsigned short>>;
#endif // __FORCE_INSTANCE
#endif // defined(_DLL_CPPLIB)
// CLASS TEMPLATE basic_iostream
template <class _Elem, class _Traits>
class basic_iostream : public basic_istream<_Elem, _Traits>,
public basic_ostream<_Elem, _Traits> { // control insertions and extractions from a stream buffer
public:
using _Myis = basic_istream<_Elem, _Traits>;
using _Myos = basic_ostream<_Elem, _Traits>;
using _Myios = basic_ios<_Elem, _Traits>;
using char_type = _Elem;
using traits_type = _Traits;
using int_type = typename _Traits::int_type;
using pos_type = typename _Traits::pos_type;
using off_type = typename _Traits::off_type;
explicit __CLR_OR_THIS_CALL basic_iostream(basic_streambuf<_Elem, _Traits>* _Strbuf)
: _Myis(_Strbuf, false), _Myos(_Noinit, false) {}
protected:
__CLR_OR_THIS_CALL basic_iostream(basic_iostream&& _Right) : _Myis(_Right.rdbuf(), false), _Myos(_Noinit, false) {
_Myios::init();
_Myios::move(_STD move(_Right));
}
basic_iostream& __CLR_OR_THIS_CALL operator=(basic_iostream&& _Right) {
this->swap(_Right);
return *this;
}
void __CLR_OR_THIS_CALL swap(basic_iostream& _Right) {
if (this != _STD addressof(_Right)) {
_Myios::swap(_Right);
}
}
public:
__CLR_OR_THIS_CALL basic_iostream(const basic_iostream&) = delete;
basic_iostream& __CLR_OR_THIS_CALL operator=(const basic_iostream&) = delete;
virtual __CLR_OR_THIS_CALL ~basic_iostream() noexcept {}
};
#if defined(_DLL_CPPLIB)
#if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
template class _CRTIMP2_PURE_IMPORT basic_iostream<char, char_traits<char>>;
template class _CRTIMP2_PURE_IMPORT basic_iostream<wchar_t, char_traits<wchar_t>>;
#endif // !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
#ifdef __FORCE_INSTANCE
template class _CRTIMP2_PURE_IMPORT basic_iostream<unsigned short, char_traits<unsigned short>>;
#endif // __FORCE_INSTANCE
#endif // defined(_DLL_CPPLIB)
// EXTRACTORS
template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& _Istream_extract_into_buffer(
basic_istream<_Elem, _Traits>& _Istr, size_t _Size, _Elem* _Str) {
using _Myis = basic_istream<_Elem, _Traits>;
using _Ctype = ctype<_Elem>;
ios_base::iostate _State = ios_base::goodbit;
size_t _Current = 0;
const typename _Myis::sentry _Ok(_Istr);
if (_Ok) { // state okay, extract characters
const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Istr.getloc());
_TRY_IO_BEGIN
size_t _Count = _Size;
const size_t _Width = static_cast<size_t>(_Istr.width());
if (_Width > 0 && _Width < _Size) {
_Count = _Width;
}
typename _Myis::int_type _Meta = _Istr.rdbuf()->sgetc();
_Elem _Ch;
for (; _Current < _Count - 1; _Meta = _Istr.rdbuf()->snextc(), (void) ++_Current) {
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
_State |= ios_base::eofbit;
break;
} else if (_Ctype_fac.is(_Ctype::space, _Ch = _Traits::to_char_type(_Meta)) || _Ch == _Elem()) {
break; // whitespace or nul, quit
} else {
_Str[_Current] = _Traits::to_char_type(_Meta); // add it to string
}
}
_CATCH_IO_(ios_base, _Istr)
}
__analysis_assume(static_cast<size_t>(_Current) < _Size); // TRANSITION, VSO-860375
_Str[_Current] = _Elem(); // add terminating null character
_Istr.width(0);
if (_Current == 0) {
_State |= ios_base::failbit;
}
_Istr.setstate(_State);
return _Istr;
}
#if _HAS_CXX20 // P0487R1 Fixing operator>>(basic_istream&, CharT*)
#pragma warning(push)
#pragma warning(disable : 6001) // Using uninitialized memory '_Str'.
template <class _Elem, class _Traits, size_t _Size>
basic_istream<_Elem, _Traits>& operator>>(
basic_istream<_Elem, _Traits>& _Istr, _Out_writes_z_(_Size) _Elem (&_Str)[_Size]) {
return _Istream_extract_into_buffer(_Istr, _Size, _Str);
}
template <class _Traits, size_t _Size>
basic_istream<char, _Traits>& operator>>(
basic_istream<char, _Traits>& _Istr, _Out_writes_z_(_Size) signed char (&_Str)[_Size]) {
return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
}
template <class _Traits, size_t _Size>
basic_istream<char, _Traits>& operator>>(
basic_istream<char, _Traits>& _Istr, _Out_writes_z_(_Size) unsigned char (&_Str)[_Size]) {
return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
}
#pragma warning(pop)
#else // _HAS_CXX20
template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem* _Str) {
return _Istream_extract_into_buffer(_Istr, SIZE_MAX, _Str);
}
template <class _Traits>
basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, signed char* _Str) {
return _Istream_extract_into_buffer(_Istr, SIZE_MAX, reinterpret_cast<char*>(_Str));
}
template <class _Traits>
basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, unsigned char* _Str) {
return _Istream_extract_into_buffer(_Istr, SIZE_MAX, reinterpret_cast<char*>(_Str));
}
#endif // _HAS_CXX20
template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch) { // extract a character
using _Myis = basic_istream<_Elem, _Traits>;
typename _Myis::int_type _Meta;
ios_base::iostate _State = ios_base::goodbit;
const typename _Myis::sentry _Ok(_Istr);
if (_Ok) { // state okay, extract characters
_TRY_IO_BEGIN
_Meta = _Istr.rdbuf()->sbumpc();
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
_State |= ios_base::eofbit | ios_base::failbit; // end of file
} else {
_Ch = _Traits::to_char_type(_Meta); // got a character
}
_CATCH_IO_(ios_base, _Istr)
}
_Istr.setstate(_State);
return _Istr;
}
template <class _Traits>
basic_istream<char, _Traits>& operator>>(
basic_istream<char, _Traits>& _Istr, signed char& _Ch) { // extract a signed char
return _Istr >> reinterpret_cast<char&>(_Ch);
}
template <class _Traits>
basic_istream<char, _Traits>& operator>>(
basic_istream<char, _Traits>& _Istr, unsigned char& _Ch) { // extract an unsigned char
return _Istr >> reinterpret_cast<char&>(_Ch);
}
template <class _Istr, class _Ty, class = void>
struct _Can_stream_in : false_type {};
template <class _Istr, class _Ty>
struct _Can_stream_in<_Istr, _Ty, void_t<decltype(_STD declval<_Istr&>() >> _STD declval<_Ty>())>> : true_type {};
template <class _Istr, class _Ty,
enable_if_t<conjunction_v<is_convertible<_Istr*, ios_base*>, _Can_stream_in<_Istr, _Ty>>, int> = 0>
_Istr&& operator>>(_Istr&& _Is, _Ty&& _Val) { // extract from rvalue stream
_Is >> _STD forward<_Ty>(_Val);
return _STD move(_Is);
}
// MANIPULATORS
template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& __CLRCALL_OR_CDECL ws(basic_istream<_Elem, _Traits>& _Istr) { // consume whitespace
const typename basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);
if (_Ok) { // state okay, extract characters
ios_base::iostate _State = ios_base::goodbit;
const auto& _Ctype_fac = _STD use_facet<ctype<_Elem>>(_Istr.getloc());
_TRY_IO_BEGIN
for (typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();; _Meta = _Istr.rdbuf()->snextc()) {
if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { // end of file, quit
_State |= ios_base::eofbit;
break;
} else if (!_Ctype_fac.is(ctype<_Elem>::space, _Traits::to_char_type(_Meta))) {
break; // not whitespace, quit
}
}
_CATCH_IO_(ios_base, _Istr)
_Istr.setstate(_State);
}
return _Istr;
}
_STD_END
#pragma pop_macro("new")
_STL_RESTORE_CLANG_WARNINGS
#pragma warning(pop)
#pragma pack(pop)
#endif // _STL_COMPILER_PREPROCESSOR
#endif // _ISTREAM_