HelenOS sources
This source file includes following definitions.
- gcount
- get
- get
- get
- get
- get
- get
- getline
- getline
- ignore
- peek
- read
- readsome
- putback
- unget
- sync
- tellg
- seekg
- seekg
- swap
- ws
- move
- swap
#ifndef LIBCPP_BITS_IO_ISTREAM
#define LIBCPP_BITS_IO_ISTREAM
#include <cassert>
#include <ios>
#include <iosfwd>
#include <limits>
#include <locale>
#include <ostream>
#include <utility>
namespace std
{
template<class Char, class Traits>
class basic_istream: virtual public basic_ios<Char, Traits>
{
public:
using traits_type = Traits;
using char_type = Char;
using int_type = typename traits_type::int_type;
using pos_type = typename traits_type::pos_type;
using off_type = typename traits_type::off_type;
explicit basic_istream(basic_streambuf<Char, Traits>* sb)
: gcount_{0}
{
basic_ios<Char, Traits>::init(sb);
}
virtual ~basic_istream()
{ }
class sentry
{
public:
explicit sentry(basic_istream<Char, Traits>& is, bool noskipws = false)
: ok_{false}
{
if (!is.good())
is.setstate(ios_base::failbit);
else
{
if (is.tie())
is.tie()->flush();
if (!noskipws && ((is.flags() & ios_base::skipws) != 0))
{
const auto& ct = use_facet<ctype<Char>>(is.getloc());
while (true)
{
auto i = is.rdbuf()->sgetc();
if (Traits::eq_int_type(i, Traits::eof()))
{
is.setstate(ios_base::failbit | ios_base::eofbit);
break;
}
auto c = Traits::to_char_type(i);
if (!ct.is(ctype_base::space, c))
break;
else
is.rdbuf()->sbumpc();
}
}
}
if (is.good())
ok_ = true;
}
~sentry() = default;
explicit operator bool() const
{
return ok_;
}
sentry(const sentry&) = delete;
sentry& operator=(const sentry&) = delete;
private:
using traits_type = Traits;
bool ok_;
};
basic_istream<Char, Traits>& operator>>(
basic_istream<Char, Traits>& (*pf)(basic_istream<Char, Traits>&)
)
{
return pf(*this);
}
basic_istream<Char, Traits>& operator>>(
basic_ios<Char, Traits>& (*pf)(basic_ios<Char, Traits>&)
)
{
pf(*this);
return *this;
}
basic_istream<Char, Traits>& operator>>(
ios_base& (*pf)(ios_base&)
)
{
pf(*this);
return *this;
}
basic_istream<Char, Traits>& operator>>(bool& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, x);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(short& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
long tmp{};
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, tmp);
if (tmp < numeric_limits<short>::min())
{
err |= ios_base::failbit;
x = numeric_limits<short>::min();
}
else if (numeric_limits<short>::max() < tmp)
{
err |= ios_base::failbit;
x = numeric_limits<short>::max();
}
else
x = static_cast<short>(tmp);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(unsigned short& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, x);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(int& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
long tmp{};
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, tmp);
if (tmp < numeric_limits<int>::min())
{
err |= ios_base::failbit;
x = numeric_limits<int>::min();
}
else if (numeric_limits<int>::max() < tmp)
{
err |= ios_base::failbit;
x = numeric_limits<int>::max();
}
else
x = static_cast<int>(tmp);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(unsigned int& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, x);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(long& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, x);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(unsigned long& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, x);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(long long& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, x);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(unsigned long long& x)
{
sentry sen{*this, false};
if (sen)
{
using num_get = num_get<Char, istreambuf_iterator<Char, Traits>>;
auto err = ios_base::goodbit;
auto loc = this->getloc();
use_facet<num_get>(loc).get(*this, 0, *this, err, x);
this->setstate(err);
}
return *this;
}
basic_istream<Char, Traits>& operator>>(float& x)
{
__unimplemented();
return *this;
}
basic_istream<Char, Traits>& operator>>(double& x)
{
__unimplemented();
return *this;
}
basic_istream<Char, Traits>& operator>>(long double& x)
{
__unimplemented();
return *this;
}
basic_istream<Char, Traits>& operator>>(void*& p)
{
__unimplemented();
return *this;
}
basic_istream<Char, Traits>& operator>>(basic_streambuf<Char, Traits>* sb)
{
if (!sb)
{
this->setstate(ios_base::failbit);
return *this;
}
gcount_ = 0;
sentry sen{*this, false};
if (sen)
{
while (true)
{
auto ic = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(ic, traits_type::eof()))
{
this->setstate(ios_base::eofbit);
break;
}
auto res = sb->sputc(traits_type::to_char_type(ic));
if (traits_type::eq_int_type(res, traits_type::eof()))
break;
++gcount_;
this->rdbuf()->sbumpc();
}
}
return *this;
}
streamsize gcount() const
{
return gcount_;
}
int_type get()
{
gcount_ = 0;
sentry sen{*this, true};
if (sen)
{
auto res = this->rdbuf()->sbumpc();
if (!traits_type::eq_int_type(res, traits_type::eof()))
{
gcount_ = 1;
return res;
}
this->setstate(ios_base::failbit | ios_base::eofbit);
}
return traits_type::eof();
}
basic_istream<Char, Traits>& get(char_type& c)
{
auto res = get();
if (res != traits_type::eof())
c = traits_type::to_char_type(res);
return *this;
}
basic_istream<Char, Traits>& get(char_type* s, streamsize n, char_type delim)
{
gcount_ = 0;
sentry sen{*this, true};
if (sen && n > 0)
{
while(gcount_ < n - 1)
{
auto c = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(c, traits_type::eof()))
{
this->setstate(ios_base::eofbit);
break;
}
s[gcount_++] = traits_type::to_char_type(c);
auto peek = traits_type::to_char_type(this->rdbuf()->sgetc());
if (traits_type::eq(peek, delim))
break;
}
if (gcount_ == 0)
this->setstate(ios_base::failbit);
s[n] = char_type{};
}
return *this;
}
basic_istream<Char, Traits>& get(char_type* s, streamsize n)
{
return get(s, n, this->widen('\n'));
}
basic_istream<Char, Traits>& get(basic_streambuf<Char, Traits>& sb)
{
get(sb, this->widen('\n'));
}
basic_istream<Char, Traits>& get(basic_streambuf<Char, Traits>& sb, char_type delim)
{
gcount_ = 0;
sentry sen{*this, true};
if (sen)
{
while (true)
{
auto i = this->rdbuf()->sgetc();
if (traits_type::eq_int_type(i, traits_type::eof()))
{
this->setstate(ios_base::eofbit);
break;
}
auto c = traits_type::to_char_type(i);
if (traits_type::eq(c, delim))
break;
auto insert_ret = sb.sputc(c);
if (traits_type::eq_int_type(insert_ret, traits_type::eof()))
break;
this->rdbuf()->sbumpc();
++gcount_;
}
if (gcount_ == 0)
this->setstate(ios_base::failbit);
}
return *this;
}
basic_istream<Char, Traits>& getline(char_type* s, streamsize n)
{
return getline(s, n, this->widen('\n'));
}
basic_istream<Char, Traits>& getline(char_type* s, streamsize n, char_type delim)
{
gcount_ = 0;
sentry sen{*this, true};
if (sen)
{
while (true)
{
auto c = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(c, traits_type::eof()))
{
this->setstate(ios_base::eofbit);
break;
}
if (traits_type::eq_int_type(c, traits_type::to_int_type(delim)))
break;
if (n < 1 || gcount_ >= n - 1)
{
this->setstate(ios_base::failbit);
break;
}
s[gcount_++] = traits_type::to_char_type(c);
}
if (gcount_ == 0)
this->setstate(ios_base::failbit);
if (n > 0)
s[gcount_] = char_type{};
}
return *this;
}
basic_istream<Char, Traits>& ignore(streamsize n = 1, int_type delim = traits_type::eof())
{
sentry sen{*this, true};
if (sen)
{
streamsize i{};
while (n == numeric_limits<streamsize>::max() || i < n)
{
auto c = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(c, traits_type::eof()))
{
this->setstate(ios_base::eofbit);
break;
}
if (traits_type::eq_int_type(c, delim))
break;
}
}
return *this;
}
int_type peek()
{
sentry sen{*this, true};
if (!this->good())
return traits_type::eof();
else
return this->rdbuf()->sgetc();
}
basic_istream<Char, Traits>& read(char_type* s, streamsize n)
{
gcount_ = 0;
sentry sen{*this, true};
if (!this->good())
{
this->setstate(ios_base::failbit);
return *this;
}
while (gcount_ < n)
{
auto c = this->rdbuf()->sbumpc();
if (traits_type::eq_int_type(c, traits_type::eof()))
{
this->setstate(ios_base::failbit | ios_base::eofbit);
break;
}
s[gcount_++] = traits_type::to_char_type(c);
}
return *this;
}
streamsize readsome(char_type* s, streamsize n)
{
gcount_ = 0;
sentry sen{*this, true};
if (!this->good())
{
this->setstate(ios_base::failbit);
return streamsize{};
}
auto avail = this->rdbuf()->in_avail();
if (avail == -1)
{
this->setstate(ios_base::eofbit);
return streamsize{};
} else if (avail > 0)
{
auto count = (avail < n ? avail : n);
while (gcount_ < count)
s[gcount_++] = traits_type::to_char_type(this->rdbuf()->sbumpc());
}
return gcount_;
}
basic_istream<Char, Traits>& putback(char_type c)
{
this->clear(this->rdstate() & (~ios_base::eofbit));
gcount_ = 0;
sentry sen{*this, true};
if (!this->good())
{
this->setstate(ios_base::failbit);
return *this;
}
if (this->rdbuf())
{
auto ret = this->rdbuf()->sputbackc(c);
if (traits_type::eq_int_type(ret, traits_type::eof()))
this->setstate(ios_base::badbit);
}
else
this->setstate(ios_base::badbit);
return *this;
}
basic_istream<Char, Traits>& unget()
{
this->clear(this->rdstate() & (~ios_base::eofbit));
gcount_ = 0;
sentry sen{*this, true};
if (!this->good())
{
this->setstate(ios_base::failbit);
return *this;
}
if (this->rdbuf())
{
auto ret = this->rdbuf()->sungetc();
if (traits_type::eq_int_type(ret, traits_type::eof()))
this->setstate(ios_base::badbit);
}
else
this->setstate(ios_base::badbit);
return *this;
}
int sync()
{
sentry s{*this, true};
if (this->rdbuf())
{
auto ret = this->rdbuf()->pubsync();
if (ret == -1)
{
this->setstate(ios_base::badbit);
return -1;
}
else
return 0;
}
else
return -1;
}
pos_type tellg()
{
sentry s{*this, true};
if (this->fail())
return pos_type(-1);
else
return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
}
basic_istream<Char, Traits>& seekg(pos_type pos)
{
this->clear(this->rdstate() & (~ios_base::eofbit));
sentry sen{*this, true};
if (!this->fail())
this->rdbuf()->pubseekoff(pos, ios_base::in);
else
this->setstate(ios_base::failbit);
return *this;
}
basic_istream<Char, Traits>& seekg(off_type off, ios_base::seekdir dir)
{
sentry sen{*this, true};
if (!this->fail())
this->rdbuf()->pubseekoff(off, dir, ios_base::in);
else
this->setstate(ios_base::failbit);
return *this;
}
protected:
streamsize gcount_;
basic_istream(const basic_istream&) = delete;
basic_istream(basic_istream&& rhs)
{
gcount_ = rhs.gcout_;
basic_ios<Char, Traits>::move(rhs);
rhs.gcount_ = 0;
}
basic_istream& operator=(const basic_istream& rhs) = delete;
basic_istream& operator=(basic_istream&& rhs)
{
swap(rhs);
return *this;
}
void swap(basic_istream& rhs)
{
basic_ios<Char, Traits>::swap(rhs);
swap(gcount_, rhs.gcount_);
}
};
template<class Char, class Traits>
basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>& is,
Char& c)
{
typename basic_istream<Char, Traits>::sentry sen{is, false};
if (sen)
{
auto ic = is.rdbuf()->sgetc();
if (Traits::eq_int_type(ic, Traits::eof()))
{
is.setstate(ios_base::failbit | ios_base::eofbit);
return is;
}
c = Traits::to_char_type(is.rdbuf()->sbumpc());
}
return is;
}
template<class Char, class Traits>
basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>& is,
unsigned char& c)
{
return is >> reinterpret_cast<char&>(c);
}
template<class Char, class Traits>
basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>& is,
signed char& c)
{
return is >> reinterpret_cast<char&>(c);
}
template<class Char, class Traits>
basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>& is,
Char* str)
{
typename basic_istream<Char, Traits>::sentry sen{is, false};
if (sen)
{
const auto& ct = use_facet<ctype<Char>>(is.getloc());
size_t n{};
if (is.width() > 0)
n = static_cast<size_t>(is.width());
else
n = (numeric_limits<size_t>::max() / sizeof(Char)) - sizeof(Char);
size_t i{};
for (; i < n - 1; ++i)
{
auto ic = is.rdbuf()->sgetc();
if (Traits::eq_int_type(ic, Traits::eof()))
break;
auto c = Traits::to_char_type(ic);
if (ct.is(ctype_base::space, c))
break;
str[i] = c;
is.rdbuf()->sbumpc();
}
str[i] = Char{};
if (i == 0)
is.setstate(ios_base::failbit);
}
return is;
}
template<class Char, class Traits>
basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>& is,
unsigned char* str)
{
return is >> reinterpret_cast<char*>(str);
}
template<class Char, class Traits>
basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>& is,
signed char* str)
{
return is >> reinterpret_cast<char*>(str);
}
template<class Char, class Traits = char_traits<Char>>
basic_istream<Char, Traits>& ws(basic_istream<Char, Traits>& is)
{
using sentry = typename basic_istream<Char, Traits>::sentry;
sentry sen{is, true};
if (sen)
{
const auto& ct = use_facet<ctype<Char>>(is.getloc());
while (true)
{
auto i = is.rdbuf()->sgetc();
if (Traits::eq_int_type(i, Traits::eof()))
{
is.setstate(ios_base::eofbit);
break;
}
auto c = Traits::to_char_type(i);
if (!ct.is(c, ct.space))
break;
else
is.rdbuf()->sbumpc();
}
}
return is;
}
using istream = basic_istream<char>;
using wistream = basic_istream<wchar_t>;
template<class Char, class Traits>
class basic_iostream
: public basic_istream<Char, Traits>,
public basic_ostream<Char, Traits>
{
public:
using char_type = Char;
using traits_type = Traits;
using int_type = typename traits_type::int_type;
using pos_type = typename traits_type::pos_type;
using off_type = typename traits_type::off_type;
explicit basic_iostream(basic_streambuf<char_type, traits_type>* sb)
: basic_istream<char_type, traits_type>(sb),
basic_ostream<char_type, traits_type>(sb)
{ }
virtual ~basic_iostream()
{ }
protected:
basic_iostream(const basic_iostream&) = delete;
basic_iostream& operator=(const basic_iostream&) = delete;
basic_iostream(basic_iostream&& other)
: basic_istream<char_type, traits_type>(move(other))
{ }
basic_iostream& operator=(basic_iostream&& other)
{
swap(other);
}
void swap(basic_iostream& other)
{
basic_istream<char_type, traits_type>::swap(other);
}
};
using iostream = basic_iostream<char>;
using wiostream = basic_iostream<wchar_t>;
template<class Char, class Traits, class T>
basic_istream<Char, Traits>& operator>>(basic_istream<Char, Traits>&& is, T& x)
{
is >> x;
return is;
}
}
#endif
HelenOS homepage, sources at GitHub