__std_stream revision 227825
1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP___STD_STREAM 12#define _LIBCPP___STD_STREAM 13 14#include <__config> 15#include <ostream> 16#include <istream> 17#include <__locale> 18#include <cstdio> 19 20#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 21#pragma GCC system_header 22#endif 23 24_LIBCPP_BEGIN_NAMESPACE_STD 25 26static const unsigned __limit = 8; 27 28// __stdinbuf 29 30template <class _CharT> 31class _LIBCPP_HIDDEN __stdinbuf 32 : public basic_streambuf<_CharT, char_traits<_CharT> > 33{ 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 explicit __stdinbuf(FILE* __fp); 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 52 FILE* __file_; 53 const codecvt<char_type, char, state_type>* __cv_; 54 state_type __st_; 55 int __encoding_; 56 bool __always_noconv_; 57 58 __stdinbuf(const __stdinbuf&); 59 __stdinbuf& operator=(const __stdinbuf&); 60 61 int_type __getchar(bool __consume); 62}; 63 64template <class _CharT> 65__stdinbuf<_CharT>::__stdinbuf(FILE* __fp) 66 : __file_(__fp), 67 __st_() 68{ 69 imbue(this->getloc()); 70} 71 72template <class _CharT> 73void 74__stdinbuf<_CharT>::imbue(const locale& __loc) 75{ 76 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc); 77 __encoding_ = __cv_->encoding(); 78 __always_noconv_ = __cv_->always_noconv(); 79 if (__encoding_ > __limit) 80 __throw_runtime_error("unsupported locale for standard input"); 81} 82 83template <class _CharT> 84typename __stdinbuf<_CharT>::int_type 85__stdinbuf<_CharT>::underflow() 86{ 87 return __getchar(false); 88} 89 90template <class _CharT> 91typename __stdinbuf<_CharT>::int_type 92__stdinbuf<_CharT>::uflow() 93{ 94 return __getchar(true); 95} 96 97template <class _CharT> 98typename __stdinbuf<_CharT>::int_type 99__stdinbuf<_CharT>::__getchar(bool __consume) 100{ 101 char __extbuf[__limit]; 102 int __nread = _VSTD::max(1, __encoding_); 103 for (int __i = 0; __i < __nread; ++__i) 104 { 105 char __c = getc(__file_); 106 if (__c == EOF) 107 return traits_type::eof(); 108 __extbuf[__i] = static_cast<char>(__c); 109 } 110 char_type __1buf; 111 if (__always_noconv_) 112 __1buf = static_cast<char_type>(__extbuf[0]); 113 else 114 { 115 const char* __enxt; 116 char_type* __inxt; 117 codecvt_base::result __r; 118 do 119 { 120 state_type __sv_st = __st_; 121 __r = __cv_->in(__st_, __extbuf, __extbuf + __nread, __enxt, 122 &__1buf, &__1buf + 1, __inxt); 123 switch (__r) 124 { 125 case _VSTD::codecvt_base::ok: 126 break; 127 case codecvt_base::partial: 128 __st_ = __sv_st; 129 if (__nread == sizeof(__extbuf)) 130 return traits_type::eof(); 131 { 132 char __c = getc(__file_); 133 if (__c == EOF) 134 return traits_type::eof(); 135 __extbuf[__nread] = static_cast<char>(__c); 136 } 137 ++__nread; 138 break; 139 case codecvt_base::error: 140 return traits_type::eof(); 141 case _VSTD::codecvt_base::noconv: 142 __1buf = static_cast<char_type>(__extbuf[0]); 143 break; 144 } 145 } while (__r == _VSTD::codecvt_base::partial); 146 } 147 if (!__consume) 148 { 149 for (int __i = __nread; __i > 0;) 150 { 151 if (ungetc(__extbuf[--__i], __file_) == EOF) 152 return traits_type::eof(); 153 } 154 } 155 return traits_type::to_int_type(__1buf); 156} 157 158template <class _CharT> 159typename __stdinbuf<_CharT>::int_type 160__stdinbuf<_CharT>::pbackfail(int_type __c) 161{ 162 if (traits_type::eq_int_type(__c, traits_type::eof())) 163 return __c; 164 char __extbuf[__limit]; 165 char* __enxt; 166 const char_type __ci = traits_type::to_char_type(__c); 167 const char_type* __inxt; 168 switch (__cv_->out(__st_, &__ci, &__ci + 1, __inxt, 169 __extbuf, __extbuf + sizeof(__extbuf), __enxt)) 170 { 171 case _VSTD::codecvt_base::ok: 172 break; 173 case _VSTD::codecvt_base::noconv: 174 __extbuf[0] = static_cast<char>(__c); 175 __enxt = __extbuf + 1; 176 break; 177 case codecvt_base::partial: 178 case codecvt_base::error: 179 return traits_type::eof(); 180 } 181 while (__enxt > __extbuf) 182 if (ungetc(*--__enxt, __file_) == EOF) 183 return traits_type::eof(); 184 return traits_type::not_eof(__c); 185} 186 187// __stdoutbuf 188 189template <class _CharT> 190class _LIBCPP_HIDDEN __stdoutbuf 191 : public basic_streambuf<_CharT, char_traits<_CharT> > 192{ 193public: 194 typedef _CharT char_type; 195 typedef char_traits<char_type> traits_type; 196 typedef typename traits_type::int_type int_type; 197 typedef typename traits_type::pos_type pos_type; 198 typedef typename traits_type::off_type off_type; 199 typedef typename traits_type::state_type state_type; 200 201 explicit __stdoutbuf(FILE* __fp); 202 203protected: 204 virtual int_type overflow (int_type __c = traits_type::eof()); 205 virtual int sync(); 206 virtual void imbue(const locale& __loc); 207 208private: 209 FILE* __file_; 210 const codecvt<char_type, char, state_type>* __cv_; 211 state_type __st_; 212 bool __always_noconv_; 213 214 __stdoutbuf(const __stdoutbuf&); 215 __stdoutbuf& operator=(const __stdoutbuf&); 216}; 217 218template <class _CharT> 219__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp) 220 : __file_(__fp), 221 __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())), 222 __st_(), 223 __always_noconv_(__cv_->always_noconv()) 224{ 225} 226 227template <class _CharT> 228typename __stdoutbuf<_CharT>::int_type 229__stdoutbuf<_CharT>::overflow(int_type __c) 230{ 231 char __extbuf[__limit]; 232 char_type __1buf; 233 if (!traits_type::eq_int_type(__c, traits_type::eof())) 234 { 235 this->setp(&__1buf, &__1buf+1); 236 *this->pptr() = traits_type::to_char_type(__c); 237 this->pbump(1); 238 if (__always_noconv_) 239 { 240 if (fwrite(this->pbase(), sizeof(char_type), 1, __file_) != 1) 241 return traits_type::eof(); 242 } 243 else 244 { 245 char* __extbe = __extbuf; 246 codecvt_base::result __r; 247 do 248 { 249 const char_type* __e; 250 __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, 251 __extbuf, 252 __extbuf + sizeof(__extbuf), 253 __extbe); 254 if (__e == this->pbase()) 255 return traits_type::eof(); 256 if (__r == codecvt_base::noconv) 257 { 258 if (fwrite(this->pbase(), 1, 1, __file_) != 1) 259 return traits_type::eof(); 260 } 261 else if (__r == codecvt_base::ok || __r == codecvt_base::partial) 262 { 263 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf); 264 if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb) 265 return traits_type::eof(); 266 if (__r == codecvt_base::partial) 267 { 268 this->setp((char_type*)__e, this->pptr()); 269 this->pbump(this->epptr() - this->pbase()); 270 } 271 } 272 else 273 return traits_type::eof(); 274 } while (__r == codecvt_base::partial); 275 } 276 this->setp(0, 0); 277 } 278 return traits_type::not_eof(__c); 279} 280 281template <class _CharT> 282int 283__stdoutbuf<_CharT>::sync() 284{ 285 char __extbuf[__limit]; 286 codecvt_base::result __r; 287 do 288 { 289 char* __extbe; 290 __r = __cv_->unshift(__st_, __extbuf, 291 __extbuf + sizeof(__extbuf), 292 __extbe); 293 size_t __nmemb = static_cast<size_t>(__extbe - __extbuf); 294 if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb) 295 return -1; 296 } while (__r == codecvt_base::partial); 297 if (__r == codecvt_base::error) 298 return -1; 299 if (fflush(__file_)) 300 return -1; 301 return 0; 302} 303 304template <class _CharT> 305void 306__stdoutbuf<_CharT>::imbue(const locale& __loc) 307{ 308 sync(); 309 __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc); 310 __always_noconv_ = __cv_->always_noconv(); 311} 312 313_LIBCPP_END_NAMESPACE_STD 314 315#endif // _LIBCPP___STD_STREAM 316