forked from OSchip/llvm-project
314 lines
8.9 KiB
C++
314 lines
8.9 KiB
C++
// -*- 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>
|
|
|
|
#pragma GCC system_header
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
static const unsigned __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;
|
|
|
|
explicit __stdinbuf(FILE* __fp);
|
|
|
|
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_;
|
|
bool __always_noconv_;
|
|
|
|
__stdinbuf(const __stdinbuf&);
|
|
__stdinbuf& operator=(const __stdinbuf&);
|
|
|
|
int_type __getchar(bool __consume);
|
|
};
|
|
|
|
template <class _CharT>
|
|
__stdinbuf<_CharT>::__stdinbuf(FILE* __fp)
|
|
: __file_(__fp),
|
|
__st_()
|
|
{
|
|
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)
|
|
{
|
|
char __extbuf[__limit];
|
|
int __nread = _STD::max(1, __encoding_);
|
|
for (int __i = 0; __i < __nread; ++__i)
|
|
{
|
|
char __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 _STD::codecvt_base::ok:
|
|
break;
|
|
case codecvt_base::partial:
|
|
__st_ = __sv_st;
|
|
if (__nread == sizeof(__extbuf))
|
|
return traits_type::eof();
|
|
{
|
|
char __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 _STD::codecvt_base::noconv:
|
|
__1buf = static_cast<char_type>(__extbuf[0]);
|
|
break;
|
|
}
|
|
} while (__r == _STD::codecvt_base::partial);
|
|
}
|
|
if (!__consume)
|
|
{
|
|
for (int __i = __nread; __i > 0;)
|
|
{
|
|
if (ungetc(__extbuf[--__i], __file_) == EOF)
|
|
return traits_type::eof();
|
|
}
|
|
}
|
|
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()))
|
|
return __c;
|
|
char __extbuf[__limit];
|
|
char* __enxt;
|
|
const char_type __ci = traits_type::to_char_type(__c);
|
|
const char_type* __inxt;
|
|
switch (__cv_->out(__st_, &__ci, &__ci + 1, __inxt,
|
|
__extbuf, __extbuf + sizeof(__extbuf), __enxt))
|
|
{
|
|
case _STD::codecvt_base::ok:
|
|
break;
|
|
case _STD::codecvt_base::noconv:
|
|
__extbuf[0] = static_cast<char>(__c);
|
|
__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();
|
|
return traits_type::not_eof(__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;
|
|
|
|
explicit __stdoutbuf(FILE* __fp);
|
|
|
|
protected:
|
|
virtual int_type overflow (int_type __c = traits_type::eof());
|
|
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)
|
|
: __file_(__fp),
|
|
__cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
|
|
__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()))
|
|
{
|
|
this->setp(&__1buf, &__1buf+1);
|
|
*this->pptr() = traits_type::to_char_type(__c);
|
|
this->pbump(1);
|
|
if (__always_noconv_)
|
|
{
|
|
if (fwrite(this->pbase(), sizeof(char_type), 1, __file_) != 1)
|
|
return traits_type::eof();
|
|
}
|
|
else
|
|
{
|
|
char* __extbe = __extbuf;
|
|
codecvt_base::result __r;
|
|
do
|
|
{
|
|
const char_type* __e;
|
|
__r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
|
|
__extbuf,
|
|
__extbuf + sizeof(__extbuf),
|
|
__extbe);
|
|
if (__e == this->pbase())
|
|
return traits_type::eof();
|
|
if (__r == codecvt_base::noconv)
|
|
{
|
|
if (fwrite(this->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)
|
|
{
|
|
this->setp((char_type*)__e, this->pptr());
|
|
this->pbump(this->epptr() - this->pbase());
|
|
}
|
|
}
|
|
else
|
|
return traits_type::eof();
|
|
} while (__r == codecvt_base::partial);
|
|
}
|
|
this->setp(0, 0);
|
|
}
|
|
return traits_type::not_eof(__c);
|
|
}
|
|
|
|
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
|