libcxx/include/streambuf

   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_STREAMBUF
  11 #define _LIBCPP_STREAMBUF
  12
  13 /*
  14     streambuf synopsis
  15
  16 namespace std
  17 {
  18
  19 template <class charT, class traits = char_traits<charT> >
  20 class basic_streambuf
  21 {
  22 public:
  23     // types:
  24     typedef charT char_type;
  25     typedef traits traits_type;
  26     typedef typename traits_type::int_type int_type;
  27     typedef typename traits_type::pos_type pos_type;
  28     typedef typename traits_type::off_type off_type;
  29
  30     virtual ~basic_streambuf();
  31
  32     // 27.6.2.2.1 locales:
  33     locale pubimbue(const locale& loc);
  34     locale getloc() const;
  35
  36     // 27.6.2.2.2 buffer and positioning:
  37     basic_streambuf* pubsetbuf(char_type* s, streamsize n);
  38     pos_type pubseekoff(off_type off, ios_base::seekdir way,
  39                         ios_base::openmode which = ios_base::in | ios_base::out);
  40     pos_type pubseekpos(pos_type sp,
  41                         ios_base::openmode which = ios_base::in | ios_base::out);
  42     int pubsync();
  43
  44     // Get and put areas:
  45     // 27.6.2.2.3 Get area:
  46     streamsize in_avail();
  47     int_type snextc();
  48     int_type sbumpc();
  49     int_type sgetc();
  50     streamsize sgetn(char_type* s, streamsize n);
  51
  52     // 27.6.2.2.4 Putback:
  53     int_type sputbackc(char_type c);
  54     int_type sungetc();
  55
  56     // 27.6.2.2.5 Put area:
  57     int_type sputc(char_type c);
  58     streamsize sputn(const char_type* s, streamsize n);
  59
  60 protected:
  61     basic_streambuf();
  62     basic_streambuf(const basic_streambuf& rhs);
  63     basic_streambuf& operator=(const basic_streambuf& rhs);
  64     void swap(basic_streambuf& rhs);
  65
  66     // 27.6.2.3.2 Get area:
  67     char_type* eback() const;
  68     char_type* gptr() const;
  69     char_type* egptr() const;
  70     void gbump(int n);
  71     void setg(char_type* gbeg, char_type* gnext, char_type* gend);
  72
  73     // 27.6.2.3.3 Put area:
  74     char_type* pbase() const;
  75     char_type* pptr() const;
  76     char_type* epptr() const;
  77     void pbump(int n);
  78     void setp(char_type* pbeg, char_type* pend);
  79
  80     // 27.6.2.4 virtual functions:
  81     // 27.6.2.4.1 Locales:
  82     virtual void imbue(const locale& loc);
  83
  84     // 27.6.2.4.2 Buffer management and positioning:
  85     virtual basic_streambuf* setbuf(char_type* s, streamsize n);
  86     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
  87                              ios_base::openmode which = ios_base::in | ios_base::out);
  88     virtual pos_type seekpos(pos_type sp,
  89                              ios_base::openmode which = ios_base::in | ios_base::out);
  90     virtual int sync();
  91
  92     // 27.6.2.4.3 Get area:
  93     virtual streamsize showmanyc();
  94     virtual streamsize xsgetn(char_type* s, streamsize n);
  95     virtual int_type underflow();
  96     virtual int_type uflow();
  97
  98     // 27.6.2.4.4 Putback:
  99     virtual int_type pbackfail(int_type c = traits_type::eof());
 100
 101     // 27.6.2.4.5 Put area:
 102     virtual streamsize xsputn(const char_type* s, streamsize n);
 103     virtual int_type overflow (int_type c = traits_type::eof());
 104 };
 105
 106 }  // std
 107
 108 */
 109
 110 #include <__config>
 111
 112 #if _LIBCPP_HAS_LOCALIZATION
 113
 114 #  include <__assert>
 115 #  include <__fwd/streambuf.h>
 116 #  include <__locale>
 117 #  include <__type_traits/is_same.h>
 118 #  include <__utility/is_valid_range.h>
 119 #  include <climits>
 120 #  include <ios>
 121 #  include <iosfwd>
 122 #  include <version>
 123
 124 #  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 125 #    pragma GCC system_header
 126 #  endif
 127
 128 _LIBCPP_PUSH_MACROS
 129 #  include <__undef_macros>
 130
 131 _LIBCPP_BEGIN_NAMESPACE_STD
 132
 133 template <class _CharT, class _Traits>
 134 class _LIBCPP_TEMPLATE_VIS basic_streambuf {
 135 public:
 136   // types:
 137   typedef _CharT char_type;
 138   typedef _Traits traits_type;
 139   typedef typename traits_type::int_type int_type;
 140   typedef typename traits_type::pos_type pos_type;
 141   typedef typename traits_type::off_type off_type;
 142
 143   static_assert(is_same<_CharT, typename traits_type::char_type>::value,
 144                 "traits_type::char_type must be the same type as CharT");
 145
 146   virtual ~basic_streambuf();
 147
 148   // 27.6.2.2.1 locales:
 149   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 locale pubimbue(const locale& __loc) {
 150     imbue(__loc);
 151     locale __r = __loc_;
 152     __loc_     = __loc;
 153     return __r;
 154   }
 155
 156   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 locale getloc() const { return __loc_; }
 157
 158   // 27.6.2.2.2 buffer and positioning:
 159   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_streambuf* pubsetbuf(char_type* __s, streamsize __n) {
 160     return setbuf(__s, __n);
 161   }
 162
 163   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type
 164   pubseekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) {
 165     return seekoff(__off, __way, __which);
 166   }
 167
 168   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type
 169   pubseekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) {
 170     return seekpos(__sp, __which);
 171   }
 172
 173   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int pubsync() { return sync(); }
 174
 175   // Get and put areas:
 176   // 27.6.2.2.3 Get area:
 177   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize in_avail() {
 178     if (__ninp_ < __einp_)
 179       return static_cast<streamsize>(__einp_ - __ninp_);
 180     return showmanyc();
 181   }
 182
 183   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type snextc() {
 184     if (sbumpc() == traits_type::eof())
 185       return traits_type::eof();
 186     return sgetc();
 187   }
 188
 189   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sbumpc() {
 190     if (__ninp_ == __einp_)
 191       return uflow();
 192     return traits_type::to_int_type(*__ninp_++);
 193   }
 194
 195   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sgetc() {
 196     if (__ninp_ == __einp_)
 197       return underflow();
 198     return traits_type::to_int_type(*__ninp_);
 199   }
 200
 201   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize sgetn(char_type* __s, streamsize __n) { return xsgetn(__s, __n); }
 202
 203   // 27.6.2.2.4 Putback:
 204   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sputbackc(char_type __c) {
 205     if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
 206       return pbackfail(traits_type::to_int_type(__c));
 207     return traits_type::to_int_type(*--__ninp_);
 208   }
 209
 210   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sungetc() {
 211     if (__binp_ == __ninp_)
 212       return pbackfail();
 213     return traits_type::to_int_type(*--__ninp_);
 214   }
 215
 216   // 27.6.2.2.5 Put area:
 217   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sputc(char_type __c) {
 218     if (__nout_ == __eout_)
 219       return overflow(traits_type::to_int_type(__c));
 220     *__nout_++ = __c;
 221     return traits_type::to_int_type(__c);
 222   }
 223
 224   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize sputn(const char_type* __s, streamsize __n) {
 225     return xsputn(__s, __n);
 226   }
 227
 228 protected:
 229   basic_streambuf();
 230   basic_streambuf(const basic_streambuf& __rhs);
 231   basic_streambuf& operator=(const basic_streambuf& __rhs);
 232   void swap(basic_streambuf& __rhs);
 233
 234   // 27.6.2.3.2 Get area:
 235   _LIBCPP_HIDE_FROM_ABI char_type* eback() const { return __binp_; }
 236   _LIBCPP_HIDE_FROM_ABI char_type* gptr() const { return __ninp_; }
 237   _LIBCPP_HIDE_FROM_ABI char_type* egptr() const { return __einp_; }
 238
 239   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void gbump(int __n) { __ninp_ += __n; }
 240
 241   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
 242     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gnext), "[gbeg, gnext) must be a valid range");
 243     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gend), "[gbeg, gend) must be a valid range");
 244     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gnext, __gend), "[gnext, gend) must be a valid range");
 245     __binp_ = __gbeg;
 246     __ninp_ = __gnext;
 247     __einp_ = __gend;
 248   }
 249
 250   // 27.6.2.3.3 Put area:
 251   _LIBCPP_HIDE_FROM_ABI char_type* pbase() const { return __bout_; }
 252   _LIBCPP_HIDE_FROM_ABI char_type* pptr() const { return __nout_; }
 253   _LIBCPP_HIDE_FROM_ABI char_type* epptr() const { return __eout_; }
 254
 255   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void pbump(int __n) { __nout_ += __n; }
 256
 257   _LIBCPP_HIDE_FROM_ABI void __pbump(streamsize __n) { __nout_ += __n; }
 258
 259   inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void setp(char_type* __pbeg, char_type* __pend) {
 260     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__pbeg, __pend), "[pbeg, pend) must be a valid range");
 261     __bout_ = __nout_ = __pbeg;
 262     __eout_           = __pend;
 263   }
 264
 265   // 27.6.2.4 virtual functions:
 266   // 27.6.2.4.1 Locales:
 267   virtual void imbue(const locale& __loc);
 268
 269   // 27.6.2.4.2 Buffer management and positioning:
 270   virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
 271   virtual pos_type
 272   seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out);
 273   virtual pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out);
 274   virtual int sync();
 275
 276   // 27.6.2.4.3 Get area:
 277   virtual streamsize showmanyc();
 278   virtual streamsize xsgetn(char_type* __s, streamsize __n);
 279   virtual int_type underflow();
 280   virtual int_type uflow();
 281
 282   // 27.6.2.4.4 Putback:
 283   virtual int_type pbackfail(int_type __c = traits_type::eof());
 284
 285   // 27.6.2.4.5 Put area:
 286   virtual streamsize xsputn(const char_type* __s, streamsize __n);
 287   virtual int_type overflow(int_type __c = traits_type::eof());
 288
 289 private:
 290   locale __loc_;
 291   char_type* __binp_;
 292   char_type* __ninp_;
 293   char_type* __einp_;
 294   char_type* __bout_;
 295   char_type* __nout_;
 296   char_type* __eout_;
 297 };
 298
 299 template <class _CharT, class _Traits>
 300 basic_streambuf<_CharT, _Traits>::~basic_streambuf() {}
 301
 302 template <class _CharT, class _Traits>
 303 basic_streambuf<_CharT, _Traits>::basic_streambuf()
 304     : __binp_(nullptr), __ninp_(nullptr), __einp_(nullptr), __bout_(nullptr), __nout_(nullptr), __eout_(nullptr) {}
 305
 306 template <class _CharT, class _Traits>
 307 basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
 308     : __loc_(__sb.__loc_),
 309       __binp_(__sb.__binp_),
 310       __ninp_(__sb.__ninp_),
 311       __einp_(__sb.__einp_),
 312       __bout_(__sb.__bout_),
 313       __nout_(__sb.__nout_),
 314       __eout_(__sb.__eout_) {}
 315
 316 template <class _CharT, class _Traits>
 317 basic_streambuf<_CharT, _Traits>& basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb) {
 318   __loc_  = __sb.__loc_;
 319   __binp_ = __sb.__binp_;
 320   __ninp_ = __sb.__ninp_;
 321   __einp_ = __sb.__einp_;
 322   __bout_ = __sb.__bout_;
 323   __nout_ = __sb.__nout_;
 324   __eout_ = __sb.__eout_;
 325   return *this;
 326 }
 327
 328 template <class _CharT, class _Traits>
 329 void basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb) {
 330   std::swap(__loc_, __sb.__loc_);
 331   std::swap(__binp_, __sb.__binp_);
 332   std::swap(__ninp_, __sb.__ninp_);
 333   std::swap(__einp_, __sb.__einp_);
 334   std::swap(__bout_, __sb.__bout_);
 335   std::swap(__nout_, __sb.__nout_);
 336   std::swap(__eout_, __sb.__eout_);
 337 }
 338
 339 template <class _CharT, class _Traits>
 340 void basic_streambuf<_CharT, _Traits>::imbue(const locale&) {}
 341
 342 template <class _CharT, class _Traits>
 343 basic_streambuf<_CharT, _Traits>* basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize) {
 344   return this;
 345 }
 346
 347 template <class _CharT, class _Traits>
 348 typename basic_streambuf<_CharT, _Traits>::pos_type
 349 basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir, ios_base::openmode) {
 350   return pos_type(off_type(-1));
 351 }
 352
 353 template <class _CharT, class _Traits>
 354 typename basic_streambuf<_CharT, _Traits>::pos_type
 355 basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode) {
 356   return pos_type(off_type(-1));
 357 }
 358
 359 template <class _CharT, class _Traits>
 360 int basic_streambuf<_CharT, _Traits>::sync() {
 361   return 0;
 362 }
 363
 364 template <class _CharT, class _Traits>
 365 streamsize basic_streambuf<_CharT, _Traits>::showmanyc() {
 366   return 0;
 367 }
 368
 369 template <class _CharT, class _Traits>
 370 streamsize basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n) {
 371   const int_type __eof = traits_type::eof();
 372   int_type __c;
 373   streamsize __i = 0;
 374   while (__i < __n) {
 375     if (__ninp_ < __einp_) {
 376       const streamsize __len = std::min(static_cast<streamsize>(INT_MAX), std::min(__einp_ - __ninp_, __n - __i));
 377       traits_type::copy(__s, __ninp_, __len);
 378       __s += __len;
 379       __i += __len;
 380       this->gbump(__len);
 381     } else if ((__c = uflow()) != __eof) {
 382       *__s = traits_type::to_char_type(__c);
 383       ++__s;
 384       ++__i;
 385     } else
 386       break;
 387   }
 388   return __i;
 389 }
 390
 391 template <class _CharT, class _Traits>
 392 typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::underflow() {
 393   return traits_type::eof();
 394 }
 395
 396 template <class _CharT, class _Traits>
 397 typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::uflow() {
 398   if (underflow() == traits_type::eof())
 399     return traits_type::eof();
 400   return traits_type::to_int_type(*__ninp_++);
 401 }
 402
 403 template <class _CharT, class _Traits>
 404 typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::pbackfail(int_type) {
 405   return traits_type::eof();
 406 }
 407
 408 template <class _CharT, class _Traits>
 409 streamsize basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n) {
 410   streamsize __i = 0;
 411   int_type __eof = traits_type::eof();
 412   while (__i < __n) {
 413     if (__nout_ >= __eout_) {
 414       if (overflow(traits_type::to_int_type(*__s)) == __eof)
 415         break;
 416       ++__s;
 417       ++__i;
 418     } else {
 419       streamsize __chunk_size = std::min(__eout_ - __nout_, __n - __i);
 420       traits_type::copy(__nout_, __s, __chunk_size);
 421       __nout_ += __chunk_size;
 422       __s += __chunk_size;
 423       __i += __chunk_size;
 424     }
 425   }
 426   return __i;
 427 }
 428
 429 template <class _CharT, class _Traits>
 430 typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::overflow(int_type) {
 431   return traits_type::eof();
 432 }
 433
 434 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<char>;
 435
 436 #  if _LIBCPP_HAS_WIDE_CHARACTERS
 437 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<wchar_t>;
 438 #  endif
 439
 440 _LIBCPP_END_NAMESPACE_STD
 441
 442 _LIBCPP_POP_MACROS
 443
 444 #endif // _LIBCPP_HAS_LOCALIZATION
 445
 446 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 447 #  include <cstdint>
 448 #endif
 449
 450 #endif // _LIBCPP_STREAMBUF