include/__std_stream

// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP___STD_STREAM
#define _LIBCPP___STD_STREAM

#include <__config>
#include <ostream>
#include <istream>
#include <__locale>
#include <cstdio>

#include <__undef_min_max>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif

_LIBCPP_BEGIN_NAMESPACE_STD

static const int __limit = 8;

// __stdinbuf

template <class _CharT>
class _LIBCPP_HIDDEN __stdinbuf
 : public basic_streambuf<_CharT, char_traits<_CharT> >
{
public:
 typedef _CharT char_type;
 typedef char_traits<char_type> traits_type;
 typedef typename traits_type::int_type int_type;
 typedef typename traits_type::pos_type pos_type;
 typedef typename traits_type::off_type off_type;
 typedef typename traits_type::state_type state_type;

 __stdinbuf(FILE* __fp, state_type* __st);

protected:
 virtual int_type underflow();
 virtual int_type uflow();
 virtual int_type pbackfail(int_type __c = traits_type::eof());
 virtual void imbue(const locale& __loc);

private:

 FILE* __file_;
 const codecvt<char_type, char, state_type>* __cv_;
 state_type* __st_;
 int __encoding_;
 int_type __last_consumed_;
 bool __last_consumed_is_next_;
 bool __always_noconv_;

 __stdinbuf(const __stdinbuf&);
 __stdinbuf& operator=(const __stdinbuf&);

 int_type __getchar(bool __consume);
};

template <class _CharT>
__stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)
 : __file_(__fp),
 __st_(__st),
 __last_consumed_(traits_type::eof()),
 __last_consumed_is_next_(false)
{
 imbue(this->getloc());
}

template <class _CharT>
void
__stdinbuf<_CharT>::imbue(const locale& __loc)
{
 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
 __encoding_ = __cv_->encoding();
 __always_noconv_ = __cv_->always_noconv();
 if (__encoding_ > __limit)
 __throw_runtime_error("unsupported locale for standard input");
}

template <class _CharT>
typename __stdinbuf<_CharT>::int_type
__stdinbuf<_CharT>::underflow()
{
 return __getchar(false);
}

template <class _CharT>
typename __stdinbuf<_CharT>::int_type
__stdinbuf<_CharT>::uflow()
{
 return __getchar(true);
}

template <class _CharT>
typename __stdinbuf<_CharT>::int_type
__stdinbuf<_CharT>::__getchar(bool __consume)
{
 if (__last_consumed_is_next_)
 {
 int_type __result = __last_consumed_;
 if (__consume)
 {
 __last_consumed_ = traits_type::eof();
 __last_consumed_is_next_ = false;
 }
 return __result;
 }
 char __extbuf[__limit];
 int __nread = _VSTD::max(1, __encoding_);
 for (int __i = 0; __i < __nread; ++__i)
 {
 int __c = getc(__file_);
 if (__c == EOF)
 return traits_type::eof();
 __extbuf[__i] = static_cast<char>(__c);
 }
 char_type __1buf;
 if (__always_noconv_)
 __1buf = static_cast<char_type>(__extbuf[0]);
 else
 {
 const char* __enxt;
 char_type* __inxt;
 codecvt_base::result __r;
 do
 {
 state_type __sv_st = *__st_;
 __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt,
 &__1buf, &__1buf + 1, __inxt);
 switch (__r)
 {
 case _VSTD::codecvt_base::ok:
 break;
 case codecvt_base::partial:
 *__st_ = __sv_st;
 if (__nread == sizeof(__extbuf))
 return traits_type::eof();
 {
 int __c = getc(__file_);
 if (__c == EOF)
 return traits_type::eof();
 __extbuf[__nread] = static_cast<char>(__c);
 }
 ++__nread;
 break;
 case codecvt_base::error:
 return traits_type::eof();
 case _VSTD::codecvt_base::noconv:
 __1buf = static_cast<char_type>(__extbuf[0]);
 break;
 }
 } while (__r == _VSTD::codecvt_base::partial);
 }
 if (!__consume)
 {
 for (int __i = __nread; __i > 0;)
 {
 if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
 return traits_type::eof();
 }
 }
 else
 __last_consumed_ = traits_type::to_int_type(__1buf);
 return traits_type::to_int_type(__1buf);
}

template <class _CharT>
typename __stdinbuf<_CharT>::int_type
__stdinbuf<_CharT>::pbackfail(int_type __c)
{
 if (traits_type::eq_int_type(__c, traits_type::eof()))
 {
 if (!__last_consumed_is_next_)
 {
 __c = __last_consumed_;
 __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_,
 traits_type::eof());
 }
 return __c;
 }
 if (__last_consumed_is_next_)
 {
 char __extbuf[__limit];
 char* __enxt;
 const char_type __ci = traits_type::to_char_type(__last_consumed_);
 const char_type* __inxt;
 switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt,
 __extbuf, __extbuf + sizeof(__extbuf), __enxt))
 {
 case _VSTD::codecvt_base::ok:
 break;
 case _VSTD::codecvt_base::noconv:
 __extbuf[0] = static_cast<char>(__last_consumed_);
 __enxt = __extbuf + 1;
 break;
 case codecvt_base::partial:
 case codecvt_base::error:
 return traits_type::eof();
 }
 while (__enxt > __extbuf)
 if (ungetc(*--__enxt, __file_) == EOF)
 return traits_type::eof();
 }
 __last_consumed_ = __c;
 __last_consumed_is_next_ = true;
 return __c;
}

// __stdoutbuf

template <class _CharT>
class _LIBCPP_HIDDEN __stdoutbuf
 : public basic_streambuf<_CharT, char_traits<_CharT> >
{
public:
 typedef _CharT char_type;
 typedef char_traits<char_type> traits_type;
 typedef typename traits_type::int_type int_type;
 typedef typename traits_type::pos_type pos_type;
 typedef typename traits_type::off_type off_type;
 typedef typename traits_type::state_type state_type;

 __stdoutbuf(FILE* __fp, state_type* __st);

protected:
 virtual int_type overflow (int_type __c = traits_type::eof());
 virtual streamsize xsputn(const char_type* __s, streamsize __n);
 virtual int sync();
 virtual void imbue(const locale& __loc);

private:
 FILE* __file_;
 const codecvt<char_type, char, state_type>* __cv_;
 state_type* __st_;
 bool __always_noconv_;

 __stdoutbuf(const __stdoutbuf&);
 __stdoutbuf& operator=(const __stdoutbuf&);
};

template <class _CharT>
__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
 : __file_(__fp),
 __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
 __st_(__st),
 __always_noconv_(__cv_->always_noconv())
{
}

template <class _CharT>
typename __stdoutbuf<_CharT>::int_type
__stdoutbuf<_CharT>::overflow(int_type __c)
{
 char __extbuf[__limit];
 char_type __1buf;
 if (!traits_type::eq_int_type(__c, traits_type::eof()))
 {
 __1buf = traits_type::to_char_type(__c);
 if (__always_noconv_)
 {
 if (fwrite(&__1buf, sizeof(char_type), 1, __file_) != 1)
 return traits_type::eof();
 }
 else
 {
 char* __extbe = __extbuf;
 codecvt_base::result __r;
 char_type* pbase = &__1buf;
 char_type* pptr = pbase + 1;
 do
 {
 const char_type* __e;
 __r = __cv_->out(*__st_, pbase, pptr, __e,
 __extbuf,
 __extbuf + sizeof(__extbuf),
 __extbe);
 if (__e == pbase)
 return traits_type::eof();
 if (__r == codecvt_base::noconv)
 {
 if (fwrite(pbase, 1, 1, __file_) != 1)
 return traits_type::eof();
 }
 else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
 {
 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
 if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
 return traits_type::eof();
 if (__r == codecvt_base::partial)
 {
 pbase = (char_type*)__e;
 }
 }
 else
 return traits_type::eof();
 } while (__r == codecvt_base::partial);
 }
 }
 return traits_type::not_eof(__c);
}

template <class _CharT>
streamsize
__stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)
{
 if (__always_noconv_)
 return fwrite(__s, sizeof(char_type), __n, __file_);
 streamsize __i = 0;
 for (; __i < __n; ++__i, ++__s)
 if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
 break;
 return __i;
}

template <class _CharT>
int
__stdoutbuf<_CharT>::sync()
{
 char __extbuf[__limit];
 codecvt_base::result __r;
 do
 {
 char* __extbe;
 __r = __cv_->unshift(*__st_, __extbuf,
 __extbuf + sizeof(__extbuf),
 __extbe);
 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
 if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
 return -1;
 } while (__r == codecvt_base::partial);
 if (__r == codecvt_base::error)
 return -1;
 if (fflush(__file_))
 return -1;
 return 0;
}

template <class _CharT>
void
__stdoutbuf<_CharT>::imbue(const locale& __loc)
{
 sync();
 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
 __always_noconv_ = __cv_->always_noconv();
}

_LIBCPP_END_NAMESPACE_STD

#endif // _LIBCPP___STD_STREAM