contrib/llvm-project/libcxx/include/streambuf

   1 // -*- C++ -*-
   2 //===------------------------- streambuf ----------------------------------===//
   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_STEAMBUF
  11 #define _LIBCPP_STEAMBUF
  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 #include <iosfwd>
 112 #include <ios>
 113
 114 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 115 #pragma GCC system_header
 116 #endif
 117
 118 _LIBCPP_PUSH_MACROS
 119 #include <__undef_macros>
 120
 121 _LIBCPP_BEGIN_NAMESPACE_STD
 122
 123 template <class _CharT, class _Traits>
 124 class _LIBCPP_TEMPLATE_VIS basic_streambuf
 125 {
 126 public:
 127     // types:
 128     typedef _CharT                         char_type;
 129     typedef _Traits                        traits_type;
 130     typedef typename traits_type::int_type int_type;
 131     typedef typename traits_type::pos_type pos_type;
 132     typedef typename traits_type::off_type off_type;
 133
 134     static_assert((is_same<_CharT, typename traits_type::char_type>::value),
 135                   "traits_type::char_type must be the same type as CharT");
 136
 137     virtual ~basic_streambuf();
 138
 139     // 27.6.2.2.1 locales:
 140     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 141     locale pubimbue(const locale& __loc) {
 142         imbue(__loc);
 143         locale __r = __loc_;
 144         __loc_ = __loc;
 145         return __r;
 146     }
 147
 148     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 149     locale getloc() const { return __loc_; }
 150
 151     // 27.6.2.2.2 buffer and positioning:
 152     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 153     basic_streambuf* pubsetbuf(char_type* __s, streamsize __n)
 154     { return setbuf(__s, __n); }
 155
 156     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 157     pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
 158                         ios_base::openmode __which = ios_base::in | ios_base::out)
 159     { return seekoff(__off, __way, __which); }
 160
 161     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 162     pos_type pubseekpos(pos_type __sp,
 163                         ios_base::openmode __which = ios_base::in | ios_base::out)
 164     { return seekpos(__sp, __which); }
 165
 166     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 167     int pubsync() { return sync(); }
 168
 169     // Get and put areas:
 170     // 27.6.2.2.3 Get area:
 171     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 172     streamsize in_avail() {
 173         if (__ninp_ < __einp_)
 174             return static_cast<streamsize>(__einp_ - __ninp_);
 175         return showmanyc();
 176     }
 177
 178     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 179     int_type snextc() {
 180         if (sbumpc() == traits_type::eof())
 181             return traits_type::eof();
 182         return sgetc();
 183     }
 184
 185     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 186     int_type sbumpc() {
 187         if (__ninp_ == __einp_)
 188             return uflow();
 189         return traits_type::to_int_type(*__ninp_++);
 190     }
 191
 192     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 193     int_type sgetc() {
 194         if (__ninp_ == __einp_)
 195             return underflow();
 196         return traits_type::to_int_type(*__ninp_);
 197     }
 198
 199     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 200     streamsize sgetn(char_type* __s, streamsize __n)
 201     { return xsgetn(__s, __n); }
 202
 203     // 27.6.2.2.4 Putback:
 204     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 205     int_type sputbackc(char_type __c) {
 206         if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
 207             return pbackfail(traits_type::to_int_type(__c));
 208         return traits_type::to_int_type(*--__ninp_);
 209     }
 210
 211     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 212     int_type sungetc() {
 213         if (__binp_ == __ninp_)
 214           return pbackfail();
 215         return traits_type::to_int_type(*--__ninp_);
 216     }
 217
 218     // 27.6.2.2.5 Put area:
 219     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 220     int_type sputc(char_type __c) {
 221         if (__nout_ == __eout_)
 222             return overflow(traits_type::to_int_type(__c));
 223         *__nout_++ = __c;
 224         return traits_type::to_int_type(__c);
 225     }
 226
 227     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 228     streamsize sputn(const char_type* __s, streamsize __n)
 229     { return xsputn(__s, __n); }
 230
 231 protected:
 232     basic_streambuf();
 233     basic_streambuf(const basic_streambuf& __rhs);
 234     basic_streambuf& operator=(const basic_streambuf& __rhs);
 235     void swap(basic_streambuf& __rhs);
 236
 237     // 27.6.2.3.2 Get area:
 238     _LIBCPP_INLINE_VISIBILITY char_type* eback() const {return __binp_;}
 239     _LIBCPP_INLINE_VISIBILITY char_type* gptr()  const {return __ninp_;}
 240     _LIBCPP_INLINE_VISIBILITY char_type* egptr() const {return __einp_;}
 241
 242     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 243     void gbump(int __n) { __ninp_ += __n; }
 244
 245     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 246     void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
 247         __binp_ = __gbeg;
 248         __ninp_ = __gnext;
 249         __einp_ = __gend;
 250     }
 251
 252     // 27.6.2.3.3 Put area:
 253     _LIBCPP_INLINE_VISIBILITY char_type* pbase() const {return __bout_;}
 254     _LIBCPP_INLINE_VISIBILITY char_type* pptr()  const {return __nout_;}
 255     _LIBCPP_INLINE_VISIBILITY char_type* epptr() const {return __eout_;}
 256
 257     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 258     void pbump(int __n) { __nout_ += __n; }
 259
 260     _LIBCPP_INLINE_VISIBILITY
 261     void __pbump(streamsize __n) { __nout_ += __n; }
 262
 263     inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
 264     void setp(char_type* __pbeg, char_type* __pend) {
 265         __bout_ = __nout_ = __pbeg;
 266         __eout_ = __pend;
 267     }
 268
 269     // 27.6.2.4 virtual functions:
 270     // 27.6.2.4.1 Locales:
 271     virtual void imbue(const locale& __loc);
 272
 273     // 27.6.2.4.2 Buffer management and positioning:
 274     virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
 275     virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
 276                              ios_base::openmode __which = ios_base::in | ios_base::out);
 277     virtual pos_type seekpos(pos_type __sp,
 278                              ios_base::openmode __which = ios_base::in | ios_base::out);
 279     virtual int sync();
 280
 281     // 27.6.2.4.3 Get area:
 282     virtual streamsize showmanyc();
 283     virtual streamsize xsgetn(char_type* __s, streamsize __n);
 284     virtual int_type underflow();
 285     virtual int_type uflow();
 286
 287     // 27.6.2.4.4 Putback:
 288     virtual int_type pbackfail(int_type __c = traits_type::eof());
 289
 290     // 27.6.2.4.5 Put area:
 291     virtual streamsize xsputn(const char_type* __s, streamsize __n);
 292     virtual int_type overflow(int_type __c = traits_type::eof());
 293
 294 private:
 295     locale __loc_;
 296     char_type* __binp_;
 297     char_type* __ninp_;
 298     char_type* __einp_;
 299     char_type* __bout_;
 300     char_type* __nout_;
 301     char_type* __eout_;
 302 };
 303
 304 template <class _CharT, class _Traits>
 305 basic_streambuf<_CharT, _Traits>::~basic_streambuf()
 306 {
 307 }
 308
 309 template <class _CharT, class _Traits>
 310 basic_streambuf<_CharT, _Traits>::basic_streambuf()
 311     : __binp_(0),
 312       __ninp_(0),
 313       __einp_(0),
 314       __bout_(0),
 315       __nout_(0),
 316       __eout_(0)
 317 {
 318 }
 319
 320 template <class _CharT, class _Traits>
 321 basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
 322     : __loc_(__sb.__loc_),
 323       __binp_(__sb.__binp_),
 324       __ninp_(__sb.__ninp_),
 325       __einp_(__sb.__einp_),
 326       __bout_(__sb.__bout_),
 327       __nout_(__sb.__nout_),
 328       __eout_(__sb.__eout_)
 329 {
 330 }
 331
 332 template <class _CharT, class _Traits>
 333 basic_streambuf<_CharT, _Traits>&
 334 basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb)
 335 {
 336     __loc_ = __sb.__loc_;
 337     __binp_ = __sb.__binp_;
 338     __ninp_ = __sb.__ninp_;
 339     __einp_ = __sb.__einp_;
 340     __bout_ = __sb.__bout_;
 341     __nout_ = __sb.__nout_;
 342     __eout_ = __sb.__eout_;
 343     return *this;
 344 }
 345
 346 template <class _CharT, class _Traits>
 347 void
 348 basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
 349 {
 350     _VSTD::swap(__loc_, __sb.__loc_);
 351     _VSTD::swap(__binp_, __sb.__binp_);
 352     _VSTD::swap(__ninp_, __sb.__ninp_);
 353     _VSTD::swap(__einp_, __sb.__einp_);
 354     _VSTD::swap(__bout_, __sb.__bout_);
 355     _VSTD::swap(__nout_, __sb.__nout_);
 356     _VSTD::swap(__eout_, __sb.__eout_);
 357 }
 358
 359 template <class _CharT, class _Traits>
 360 void
 361 basic_streambuf<_CharT, _Traits>::imbue(const locale&)
 362 {
 363 }
 364
 365 template <class _CharT, class _Traits>
 366 basic_streambuf<_CharT, _Traits>*
 367 basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
 368 {
 369     return this;
 370 }
 371
 372 template <class _CharT, class _Traits>
 373 typename basic_streambuf<_CharT, _Traits>::pos_type
 374 basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
 375                                           ios_base::openmode)
 376 {
 377     return pos_type(off_type(-1));
 378 }
 379
 380 template <class _CharT, class _Traits>
 381 typename basic_streambuf<_CharT, _Traits>::pos_type
 382 basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
 383 {
 384     return pos_type(off_type(-1));
 385 }
 386
 387 template <class _CharT, class _Traits>
 388 int
 389 basic_streambuf<_CharT, _Traits>::sync()
 390 {
 391     return 0;
 392 }
 393
 394 template <class _CharT, class _Traits>
 395 streamsize
 396 basic_streambuf<_CharT, _Traits>::showmanyc()
 397 {
 398     return 0;
 399 }
 400
 401 template <class _CharT, class _Traits>
 402 streamsize
 403 basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
 404 {
 405     const int_type __eof = traits_type::eof();
 406     int_type __c;
 407     streamsize __i = 0;
 408     while(__i < __n)
 409     {
 410         if (__ninp_ < __einp_)
 411         {
 412             const streamsize __len = _VSTD::min(static_cast<streamsize>(INT_MAX),
 413                                 _VSTD::min(__einp_ - __ninp_, __n - __i));
 414             traits_type::copy(__s, __ninp_, __len);
 415             __s +=  __len;
 416             __i +=  __len;
 417             this->gbump(__len);
 418         }
 419         else if ((__c = uflow()) != __eof)
 420         {
 421             *__s = traits_type::to_char_type(__c);
 422             ++__s;
 423             ++__i;
 424         }
 425         else
 426             break;
 427     }
 428     return __i;
 429 }
 430
 431 template <class _CharT, class _Traits>
 432 typename basic_streambuf<_CharT, _Traits>::int_type
 433 basic_streambuf<_CharT, _Traits>::underflow()
 434 {
 435     return traits_type::eof();
 436 }
 437
 438 template <class _CharT, class _Traits>
 439 typename basic_streambuf<_CharT, _Traits>::int_type
 440 basic_streambuf<_CharT, _Traits>::uflow()
 441 {
 442     if (underflow() == traits_type::eof())
 443         return traits_type::eof();
 444     return traits_type::to_int_type(*__ninp_++);
 445 }
 446
 447 template <class _CharT, class _Traits>
 448 typename basic_streambuf<_CharT, _Traits>::int_type
 449 basic_streambuf<_CharT, _Traits>::pbackfail(int_type)
 450 {
 451     return traits_type::eof();
 452 }
 453
 454 template <class _CharT, class _Traits>
 455 streamsize
 456 basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
 457 {
 458     streamsize __i = 0;
 459     int_type __eof = traits_type::eof();
 460     while( __i < __n)
 461     {
 462         if (__nout_ >= __eout_)
 463         {
 464             if (overflow(traits_type::to_int_type(*__s)) == __eof)
 465                 break;
 466             ++__s;
 467             ++__i;
 468         }
 469         else
 470         {
 471             streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i);
 472             traits_type::copy(__nout_, __s, __chunk_size);
 473             __nout_ += __chunk_size;
 474             __s     += __chunk_size;
 475             __i     += __chunk_size;
 476         }
 477     }
 478     return __i;
 479 }
 480
 481 template <class _CharT, class _Traits>
 482 typename basic_streambuf<_CharT, _Traits>::int_type
 483 basic_streambuf<_CharT, _Traits>::overflow(int_type)
 484 {
 485     return traits_type::eof();
 486 }
 487
 488 #ifndef _LIBCPP_DO_NOT_ASSUME_STREAMS_EXPLICIT_INSTANTIATION_IN_DYLIB
 489 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<char>)
 490 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<wchar_t>)
 491
 492 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<char>)
 493 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t>)
 494 #endif
 495
 496 _LIBCPP_END_NAMESPACE_STD
 497
 498 _LIBCPP_POP_MACROS
 499
 500 #endif  // _LIBCPP_STEAMBUF