| // -*- 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; | |
| char_type* epptr = pptr; | |
| 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 |