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