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-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_STD_STREAM_H
11#define _LIBCPP_STD_STREAM_H
12
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_header
21#endif
22
23_LIBCPP_PUSH_MACROS
24#include <__undef_macros>
25
26_LIBCPP_BEGIN_NAMESPACE_STD
27
28static const int __limit = 8;
29
30// __stdinbuf
31
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#else
62 static constexpr bool __is_win32api_wide_char = false;
63#endif
64
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(loc: this->getloc());
75 // On Windows, in wchar_t mode, ignore the codecvt from the locale by
76 // default and assume noconv; this passes wchar_t through unmodified from
77 // 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(consume: false);
95}
96
97template <class _CharT>
98typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::uflow() {
99 return __getchar(consume: true);
100}
101
102inline bool __do_getc(FILE* __fp, char* __pbuf) {
103 int __c = getc(stream: __fp);
104 if (__c == EOF)
105 return false;
106 *__pbuf = static_cast<char>(__c);
107 return true;
108}
109#if _LIBCPP_HAS_WIDE_CHARACTERS
110inline bool __do_getc(FILE* __fp, wchar_t* __pbuf) {
111 wint_t __c = getwc(stream: __fp);
112 if (__c == WEOF)
113 return false;
114 *__pbuf = static_cast<wchar_t>(__c);
115 return true;
116}
117#endif
118
119inline bool __do_ungetc(int __c, FILE* __fp, char __dummy) {
120 if (ungetc(__c, stream: __fp) == EOF)
121 return false;
122 return true;
123}
124#if _LIBCPP_HAS_WIDE_CHARACTERS
125inline bool __do_ungetc(std::wint_t __c, FILE* __fp, wchar_t __dummy) {
126 if (ungetwc(wc: __c, stream: __fp) == WEOF)
127 return false;
128 return true;
129}
130#endif
131
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 } else
150 __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(a: 1, b: __encoding_);
156 for (int __i = 0; __i < __nread; ++__i) {
157 int __c = getc(stream: __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(stream: __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 } else
197 __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(c: *--__enxt, stream: __file_) == EOF)
231 return traits_type::eof();
232 }
233 __last_consumed_ = __c;
234 __last_consumed_is_next_ = true;
235 return __c;
236}
237
238// __stdoutbuf
239
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#else
267 static constexpr bool __is_win32api_wide_char = false;
268#endif
269
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 by
283 // default and assume noconv; this passes wchar_t through unmodified to
284 // fputwc, which handles it correctly depending on the actual mode of the
285 // output stream. If the user sets a custom locale with imbue(), that
286 // 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(ptr: &__c, size: sizeof(__c), n: 1, s: __fp) != 1)
293 return false;
294 return true;
295}
296#if _LIBCPP_HAS_WIDE_CHARACTERS
297inline bool __do_fputc(wchar_t __c, FILE* __fp) {
298 // fputwc works regardless of wide/narrow mode of stdout, while
299 // fwrite of wchar_t only works if the stream actually has been set
300 // into wide mode.
301 if (fputwc(wc: __c, stream: __fp) == WEOF)
302 return false;
303 return true;
304}
305#endif
306
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(ptr: __extbuf, size: 1, n: __nmemb, s: __file_) != __nmemb)
332 return traits_type::eof();
333 if (__r == codecvt_base::partial) {
334 pbase = const_cast<char_type*>(__e);
335 }
336 } else
337 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 one
347 // at a time with fputwc(); that works both when stdout is in the default
348 // 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(c: 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(ptr: __extbuf, size: 1, n: __nmemb, s: __file_) != __nmemb)
367 return -1;
368 } while (__r == codecvt_base::partial);
369 if (__r == codecvt_base::error)
370 return -1;
371 if (fflush(stream: __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_STD
384
385_LIBCPP_POP_MACROS
386
387#endif // _LIBCPP_STD_STREAM_H
388