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