388 lines · c
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP_STD_STREAM_H11#define _LIBCPP_STD_STREAM_H12 13#include <__config>14#include <__locale>15#include <cstdio>16#include <istream>17#include <ostream>18 19#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)20# pragma GCC system_header21#endif22 23_LIBCPP_PUSH_MACROS24#include <__undef_macros>25 26_LIBCPP_BEGIN_NAMESPACE_STD27 28static const int __limit = 8;29 30// __stdinbuf31 32template <class _CharT>33class _LIBCPP_HIDDEN __stdinbuf : public basic_streambuf<_CharT, char_traits<_CharT> > {34public:35 typedef _CharT char_type;36 typedef char_traits<char_type> traits_type;37 typedef typename traits_type::int_type int_type;38 typedef typename traits_type::pos_type pos_type;39 typedef typename traits_type::off_type off_type;40 typedef typename traits_type::state_type state_type;41 42 __stdinbuf(FILE* __fp, state_type* __st);43 44protected:45 virtual int_type underflow();46 virtual int_type uflow();47 virtual int_type pbackfail(int_type __c = traits_type::eof());48 virtual void imbue(const locale& __loc);49 50private:51 FILE* __file_;52 const codecvt<char_type, char, state_type>* __cv_;53 state_type* __st_;54 int __encoding_;55 int_type __last_consumed_;56 bool __last_consumed_is_next_;57 bool __always_noconv_;58 59#if defined(_LIBCPP_WIN32API)60 static constexpr bool __is_win32api_wide_char = !is_same_v<_CharT, char>;61#else62 static constexpr bool __is_win32api_wide_char = false;63#endif64 65 __stdinbuf(const __stdinbuf&);66 __stdinbuf& operator=(const __stdinbuf&);67 68 int_type __getchar(bool __consume);69};70 71template <class _CharT>72__stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)73 : __file_(__fp), __st_(__st), __last_consumed_(traits_type::eof()), __last_consumed_is_next_(false) {74 imbue(this->getloc());75 // On Windows, in wchar_t mode, ignore the codecvt from the locale by76 // default and assume noconv; this passes wchar_t through unmodified from77 // getwc. If the user sets a custom locale with imbue(), that gets honored,78 // the IO is done with getc() and converted with the provided codecvt.79 if constexpr (__is_win32api_wide_char)80 __always_noconv_ = true;81}82 83template <class _CharT>84void __stdinbuf<_CharT>::imbue(const locale& __loc) {85 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);86 __encoding_ = __cv_->encoding();87 __always_noconv_ = __cv_->always_noconv();88 if (__encoding_ > __limit)89 std::__throw_runtime_error("unsupported locale for standard input");90}91 92template <class _CharT>93typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::underflow() {94 return __getchar(false);95}96 97template <class _CharT>98typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::uflow() {99 return __getchar(true);100}101 102inline bool __do_getc(FILE* __fp, char* __pbuf) {103 int __c = getc(__fp);104 if (__c == EOF)105 return false;106 *__pbuf = static_cast<char>(__c);107 return true;108}109#if _LIBCPP_HAS_WIDE_CHARACTERS110inline bool __do_getc(FILE* __fp, wchar_t* __pbuf) {111 wint_t __c = getwc(__fp);112 if (__c == WEOF)113 return false;114 *__pbuf = static_cast<wchar_t>(__c);115 return true;116}117#endif118 119inline bool __do_ungetc(int __c, FILE* __fp, char __dummy) {120 if (ungetc(__c, __fp) == EOF)121 return false;122 return true;123}124#if _LIBCPP_HAS_WIDE_CHARACTERS125inline bool __do_ungetc(std::wint_t __c, FILE* __fp, wchar_t __dummy) {126 if (ungetwc(__c, __fp) == WEOF)127 return false;128 return true;129}130#endif131 132template <class _CharT>133typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::__getchar(bool __consume) {134 if (__last_consumed_is_next_) {135 int_type __result = __last_consumed_;136 if (__consume) {137 __last_consumed_ = traits_type::eof();138 __last_consumed_is_next_ = false;139 }140 return __result;141 }142 if (__always_noconv_) {143 char_type __1buf;144 if (!__do_getc(__file_, &__1buf))145 return traits_type::eof();146 if (!__consume) {147 if (!__do_ungetc(traits_type::to_int_type(__1buf), __file_, __1buf))148 return traits_type::eof();149 } else150 __last_consumed_ = traits_type::to_int_type(__1buf);151 return traits_type::to_int_type(__1buf);152 }153 154 char __extbuf[__limit];155 int __nread = std::max(1, __encoding_);156 for (int __i = 0; __i < __nread; ++__i) {157 int __c = getc(__file_);158 if (__c == EOF)159 return traits_type::eof();160 __extbuf[__i] = static_cast<char>(__c);161 }162 char_type __1buf;163 const char* __enxt;164 char_type* __inxt;165 codecvt_base::result __r;166 do {167 state_type __sv_st = *__st_;168 __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt, &__1buf, &__1buf + 1, __inxt);169 switch (__r) {170 case std::codecvt_base::ok:171 break;172 case codecvt_base::partial:173 *__st_ = __sv_st;174 if (__nread == sizeof(__extbuf))175 return traits_type::eof();176 {177 int __c = getc(__file_);178 if (__c == EOF)179 return traits_type::eof();180 __extbuf[__nread] = static_cast<char>(__c);181 }182 ++__nread;183 break;184 case codecvt_base::error:185 return traits_type::eof();186 case std::codecvt_base::noconv:187 __1buf = static_cast<char_type>(__extbuf[0]);188 break;189 }190 } while (__r == std::codecvt_base::partial);191 if (!__consume) {192 for (int __i = __nread; __i > 0;) {193 if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)194 return traits_type::eof();195 }196 } else197 __last_consumed_ = traits_type::to_int_type(__1buf);198 return traits_type::to_int_type(__1buf);199}200 201template <class _CharT>202typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::pbackfail(int_type __c) {203 if (traits_type::eq_int_type(__c, traits_type::eof())) {204 if (!__last_consumed_is_next_) {205 __c = __last_consumed_;206 __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_, traits_type::eof());207 }208 return __c;209 }210 if (__always_noconv_ && __last_consumed_is_next_) {211 if (!__do_ungetc(__last_consumed_, __file_, traits_type::to_char_type(__last_consumed_)))212 return traits_type::eof();213 } else if (__last_consumed_is_next_) {214 char __extbuf[__limit];215 char* __enxt;216 const char_type __ci = traits_type::to_char_type(__last_consumed_);217 const char_type* __inxt;218 switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt, __extbuf, __extbuf + sizeof(__extbuf), __enxt)) {219 case std::codecvt_base::ok:220 break;221 case std::codecvt_base::noconv:222 __extbuf[0] = static_cast<char>(__last_consumed_);223 __enxt = __extbuf + 1;224 break;225 case codecvt_base::partial:226 case codecvt_base::error:227 return traits_type::eof();228 }229 while (__enxt > __extbuf)230 if (ungetc(*--__enxt, __file_) == EOF)231 return traits_type::eof();232 }233 __last_consumed_ = __c;234 __last_consumed_is_next_ = true;235 return __c;236}237 238// __stdoutbuf239 240template <class _CharT>241class _LIBCPP_HIDDEN __stdoutbuf : public basic_streambuf<_CharT, char_traits<_CharT> > {242public:243 typedef _CharT char_type;244 typedef char_traits<char_type> traits_type;245 typedef typename traits_type::int_type int_type;246 typedef typename traits_type::pos_type pos_type;247 typedef typename traits_type::off_type off_type;248 typedef typename traits_type::state_type state_type;249 250 __stdoutbuf(FILE* __fp, state_type* __st);251 252protected:253 virtual int_type overflow(int_type __c = traits_type::eof());254 virtual streamsize xsputn(const char_type* __s, streamsize __n);255 virtual int sync();256 virtual void imbue(const locale& __loc);257 258private:259 FILE* __file_;260 const codecvt<char_type, char, state_type>* __cv_;261 state_type* __st_;262 bool __always_noconv_;263 264#if defined(_LIBCPP_WIN32API)265 static constexpr bool __is_win32api_wide_char = !is_same_v<_CharT, char>;266#else267 static constexpr bool __is_win32api_wide_char = false;268#endif269 270 __stdoutbuf(const __stdoutbuf&);271 __stdoutbuf& operator=(const __stdoutbuf&);272 273 _LIBCPP_EXPORTED_FROM_ABI friend FILE* __get_ostream_file(ostream&);274};275 276template <class _CharT>277__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)278 : __file_(__fp),279 __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),280 __st_(__st),281 __always_noconv_(__cv_->always_noconv()) {282 // On Windows, in wchar_t mode, ignore the codecvt from the locale by283 // default and assume noconv; this passes wchar_t through unmodified to284 // fputwc, which handles it correctly depending on the actual mode of the285 // output stream. If the user sets a custom locale with imbue(), that286 // gets honored.287 if constexpr (__is_win32api_wide_char)288 __always_noconv_ = true;289}290 291inline bool __do_fputc(char __c, FILE* __fp) {292 if (fwrite(&__c, sizeof(__c), 1, __fp) != 1)293 return false;294 return true;295}296#if _LIBCPP_HAS_WIDE_CHARACTERS297inline bool __do_fputc(wchar_t __c, FILE* __fp) {298 // fputwc works regardless of wide/narrow mode of stdout, while299 // fwrite of wchar_t only works if the stream actually has been set300 // into wide mode.301 if (fputwc(__c, __fp) == WEOF)302 return false;303 return true;304}305#endif306 307template <class _CharT>308typename __stdoutbuf<_CharT>::int_type __stdoutbuf<_CharT>::overflow(int_type __c) {309 char __extbuf[__limit];310 char_type __1buf;311 if (!traits_type::eq_int_type(__c, traits_type::eof())) {312 __1buf = traits_type::to_char_type(__c);313 if (__always_noconv_) {314 if (!__do_fputc(__1buf, __file_))315 return traits_type::eof();316 } else {317 char* __extbe = __extbuf;318 codecvt_base::result __r;319 char_type* pbase = &__1buf;320 char_type* pptr = pbase + 1;321 do {322 const char_type* __e;323 __r = __cv_->out(*__st_, pbase, pptr, __e, __extbuf, __extbuf + sizeof(__extbuf), __extbe);324 if (__e == pbase)325 return traits_type::eof();326 if (__r == codecvt_base::noconv) {327 if (fwrite(pbase, 1, 1, __file_) != 1)328 return traits_type::eof();329 } else if (__r == codecvt_base::ok || __r == codecvt_base::partial) {330 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);331 if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)332 return traits_type::eof();333 if (__r == codecvt_base::partial) {334 pbase = const_cast<char_type*>(__e);335 }336 } else337 return traits_type::eof();338 } while (__r == codecvt_base::partial);339 }340 }341 return traits_type::not_eof(__c);342}343 344template <class _CharT>345streamsize __stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n) {346 // For wchar_t on Windows, don't call fwrite(), but write characters one347 // at a time with fputwc(); that works both when stdout is in the default348 // mode and when it is set to Unicode mode.349 if (__always_noconv_ && !__is_win32api_wide_char)350 return fwrite(__s, sizeof(char_type), __n, __file_);351 streamsize __i = 0;352 for (; __i < __n; ++__i, ++__s)353 if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())354 break;355 return __i;356}357 358template <class _CharT>359int __stdoutbuf<_CharT>::sync() {360 char __extbuf[__limit];361 codecvt_base::result __r;362 do {363 char* __extbe;364 __r = __cv_->unshift(*__st_, __extbuf, __extbuf + sizeof(__extbuf), __extbe);365 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);366 if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)367 return -1;368 } while (__r == codecvt_base::partial);369 if (__r == codecvt_base::error)370 return -1;371 if (fflush(__file_))372 return -1;373 return 0;374}375 376template <class _CharT>377void __stdoutbuf<_CharT>::imbue(const locale& __loc) {378 sync();379 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);380 __always_noconv_ = __cv_->always_noconv();381}382 383_LIBCPP_END_NAMESPACE_STD384 385_LIBCPP_POP_MACROS386 387#endif // _LIBCPP_STD_STREAM_H388