contrib/libc++/include/__std_stream

   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_PUSH_MACROS
  25 #include <__undef_macros>
  26
  27
  28 _LIBCPP_BEGIN_NAMESPACE_STD
  29
  30 static const int __limit = 8;
  31
  32 // __stdinbuf
  33
  34 template <class _CharT>
  35 class _LIBCPP_HIDDEN __stdinbuf
  36     : public basic_streambuf<_CharT, char_traits<_CharT> >
  37 {
  38 public:
  39     typedef _CharT                           char_type;
  40     typedef char_traits<char_type>           traits_type;
  41     typedef typename traits_type::int_type   int_type;
  42     typedef typename traits_type::pos_type   pos_type;
  43     typedef typename traits_type::off_type   off_type;
  44     typedef typename traits_type::state_type state_type;
  45
  46     __stdinbuf(FILE* __fp, state_type* __st);
  47
  48 protected:
  49     virtual int_type underflow();
  50     virtual int_type uflow();
  51     virtual int_type pbackfail(int_type __c = traits_type::eof());
  52     virtual void imbue(const locale& __loc);
  53
  54 private:
  55
  56     FILE* __file_;
  57     const codecvt<char_type, char, state_type>* __cv_;
  58     state_type* __st_;
  59     int __encoding_;
  60     int_type __last_consumed_;
  61     bool __last_consumed_is_next_;
  62     bool __always_noconv_;
  63
  64     __stdinbuf(const __stdinbuf&);
  65     __stdinbuf& operator=(const __stdinbuf&);
  66
  67     int_type __getchar(bool __consume);
  68 };
  69
  70 template <class _CharT>
  71 __stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)
  72     : __file_(__fp),
  73       __st_(__st),
  74       __last_consumed_(traits_type::eof()),
  75       __last_consumed_is_next_(false)
  76 {
  77     imbue(this->getloc());
  78 }
  79
  80 template <class _CharT>
  81 void
  82 __stdinbuf<_CharT>::imbue(const locale& __loc)
  83 {
  84     __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
  85     __encoding_ = __cv_->encoding();
  86     __always_noconv_ = __cv_->always_noconv();
  87     if (__encoding_ > __limit)
  88         __throw_runtime_error("unsupported locale for standard input");
  89 }
  90
  91 template <class _CharT>
  92 typename __stdinbuf<_CharT>::int_type
  93 __stdinbuf<_CharT>::underflow()
  94 {
  95     return __getchar(false);
  96 }
  97
  98 template <class _CharT>
  99 typename __stdinbuf<_CharT>::int_type
 100 __stdinbuf<_CharT>::uflow()
 101 {
 102     return __getchar(true);
 103 }
 104
 105 template <class _CharT>
 106 typename __stdinbuf<_CharT>::int_type
 107 __stdinbuf<_CharT>::__getchar(bool __consume)
 108 {
 109     if (__last_consumed_is_next_)
 110     {
 111         int_type __result = __last_consumed_;
 112         if (__consume)
 113         {
 114             __last_consumed_ = traits_type::eof();
 115             __last_consumed_is_next_ = false;
 116         }
 117         return __result;
 118     }
 119     char __extbuf[__limit];
 120     int __nread = _VSTD::max(1, __encoding_);
 121     for (int __i = 0; __i < __nread; ++__i)
 122     {
 123         int __c = getc(__file_);
 124         if (__c == EOF)
 125             return traits_type::eof();
 126         __extbuf[__i] = static_cast<char>(__c);
 127     }
 128     char_type __1buf;
 129     if (__always_noconv_)
 130         __1buf = static_cast<char_type>(__extbuf[0]);
 131     else
 132     {
 133         const char* __enxt;
 134         char_type* __inxt;
 135         codecvt_base::result __r;
 136         do
 137         {
 138             state_type __sv_st = *__st_;
 139             __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt,
 140                                    &__1buf, &__1buf + 1, __inxt);
 141             switch (__r)
 142             {
 143             case _VSTD::codecvt_base::ok:
 144                 break;
 145             case codecvt_base::partial:
 146                 *__st_ = __sv_st;
 147                 if (__nread == sizeof(__extbuf))
 148                     return traits_type::eof();
 149                 {
 150                     int __c = getc(__file_);
 151                     if (__c == EOF)
 152                         return traits_type::eof();
 153                     __extbuf[__nread] = static_cast<char>(__c);
 154                 }
 155                 ++__nread;
 156                 break;
 157             case codecvt_base::error:
 158                 return traits_type::eof();
 159             case _VSTD::codecvt_base::noconv:
 160                 __1buf = static_cast<char_type>(__extbuf[0]);
 161                 break;
 162             }
 163         } while (__r == _VSTD::codecvt_base::partial);
 164     }
 165     if (!__consume)
 166     {
 167         for (int __i = __nread; __i > 0;)
 168         {
 169             if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
 170                 return traits_type::eof();
 171         }
 172     }
 173     else
 174         __last_consumed_ = traits_type::to_int_type(__1buf);
 175     return traits_type::to_int_type(__1buf);
 176 }
 177
 178 template <class _CharT>
 179 typename __stdinbuf<_CharT>::int_type
 180 __stdinbuf<_CharT>::pbackfail(int_type __c)
 181 {
 182     if (traits_type::eq_int_type(__c, traits_type::eof()))
 183     {
 184         if (!__last_consumed_is_next_)
 185         {
 186             __c = __last_consumed_;
 187             __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_,
 188                                                                  traits_type::eof());
 189         }
 190         return __c;
 191     }
 192     if (__last_consumed_is_next_)
 193     {
 194         char __extbuf[__limit];
 195         char* __enxt;
 196         const char_type __ci = traits_type::to_char_type(__last_consumed_);
 197         const char_type* __inxt;
 198         switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt,
 199                                   __extbuf, __extbuf + sizeof(__extbuf), __enxt))
 200         {
 201         case _VSTD::codecvt_base::ok:
 202             break;
 203         case _VSTD::codecvt_base::noconv:
 204             __extbuf[0] = static_cast<char>(__last_consumed_);
 205             __enxt = __extbuf + 1;
 206             break;
 207         case codecvt_base::partial:
 208         case codecvt_base::error:
 209             return traits_type::eof();
 210         }
 211         while (__enxt > __extbuf)
 212             if (ungetc(*--__enxt, __file_) == EOF)
 213                 return traits_type::eof();
 214     }
 215     __last_consumed_ = __c;
 216     __last_consumed_is_next_ = true;
 217     return __c;
 218 }
 219
 220 // __stdoutbuf
 221
 222 template <class _CharT>
 223 class _LIBCPP_HIDDEN __stdoutbuf
 224     : public basic_streambuf<_CharT, char_traits<_CharT> >
 225 {
 226 public:
 227     typedef _CharT                           char_type;
 228     typedef char_traits<char_type>           traits_type;
 229     typedef typename traits_type::int_type   int_type;
 230     typedef typename traits_type::pos_type   pos_type;
 231     typedef typename traits_type::off_type   off_type;
 232     typedef typename traits_type::state_type state_type;
 233
 234     __stdoutbuf(FILE* __fp, state_type* __st);
 235
 236 protected:
 237     virtual int_type overflow (int_type __c = traits_type::eof());
 238     virtual streamsize xsputn(const char_type* __s, streamsize __n);
 239     virtual int sync();
 240     virtual void imbue(const locale& __loc);
 241
 242 private:
 243     FILE* __file_;
 244     const codecvt<char_type, char, state_type>* __cv_;
 245     state_type* __st_;
 246     bool __always_noconv_;
 247
 248     __stdoutbuf(const __stdoutbuf&);
 249     __stdoutbuf& operator=(const __stdoutbuf&);
 250 };
 251
 252 template <class _CharT>
 253 __stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
 254     : __file_(__fp),
 255       __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
 256       __st_(__st),
 257       __always_noconv_(__cv_->always_noconv())
 258 {
 259 }
 260
 261 template <class _CharT>
 262 typename __stdoutbuf<_CharT>::int_type
 263 __stdoutbuf<_CharT>::overflow(int_type __c)
 264 {
 265     char __extbuf[__limit];
 266     char_type __1buf;
 267     if (!traits_type::eq_int_type(__c, traits_type::eof()))
 268     {
 269         __1buf = traits_type::to_char_type(__c);
 270         if (__always_noconv_)
 271         {
 272             if (fwrite(&__1buf, sizeof(char_type), 1, __file_) != 1)
 273                 return traits_type::eof();
 274         }
 275         else
 276         {
 277             char* __extbe = __extbuf;
 278             codecvt_base::result __r;
 279             char_type* pbase = &__1buf;
 280             char_type* pptr = pbase + 1;
 281             do
 282             {
 283                 const char_type* __e;
 284                 __r = __cv_->out(*__st_, pbase, pptr, __e,
 285                                         __extbuf,
 286                                         __extbuf + sizeof(__extbuf),
 287                                         __extbe);
 288                 if (__e == pbase)
 289                     return traits_type::eof();
 290                 if (__r == codecvt_base::noconv)
 291                 {
 292                     if (fwrite(pbase, 1, 1, __file_) != 1)
 293                         return traits_type::eof();
 294                 }
 295                 else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
 296                 {
 297                     size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
 298                     if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
 299                         return traits_type::eof();
 300                     if (__r == codecvt_base::partial)
 301                     {
 302                         pbase = const_cast<char_type*>(__e);
 303                     }
 304                 }
 305                 else
 306                     return traits_type::eof();
 307             } while (__r == codecvt_base::partial);
 308         }
 309     }
 310     return traits_type::not_eof(__c);
 311 }
 312
 313 template <class _CharT>
 314 streamsize
 315 __stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)
 316 {
 317     if (__always_noconv_)
 318         return fwrite(__s, sizeof(char_type), __n, __file_);
 319     streamsize __i = 0;
 320     for (; __i < __n; ++__i, ++__s)
 321         if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
 322             break;
 323     return __i;
 324 }
 325
 326 template <class _CharT>
 327 int
 328 __stdoutbuf<_CharT>::sync()
 329 {
 330     char __extbuf[__limit];
 331     codecvt_base::result __r;
 332     do
 333     {
 334         char* __extbe;
 335         __r = __cv_->unshift(*__st_, __extbuf,
 336                                     __extbuf + sizeof(__extbuf),
 337                                     __extbe);
 338         size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
 339         if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
 340             return -1;
 341     } while (__r == codecvt_base::partial);
 342     if (__r == codecvt_base::error)
 343         return -1;
 344     if (fflush(__file_))
 345         return -1;
 346     return 0;
 347 }
 348
 349 template <class _CharT>
 350 void
 351 __stdoutbuf<_CharT>::imbue(const locale& __loc)
 352 {
 353     sync();
 354     __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
 355     __always_noconv_ = __cv_->always_noconv();
 356 }
 357
 358 _LIBCPP_END_NAMESPACE_STD
 359
 360 _LIBCPP_POP_MACROS
 361
 362 #endif  // _LIBCPP___STD_STREAM