diff options
Diffstat (limited to 'third_party/libcxx/include/c++/v1/streambuf')
| -rw-r--r-- | third_party/libcxx/include/c++/v1/streambuf | 445 |
1 files changed, 445 insertions, 0 deletions
diff --git a/third_party/libcxx/include/c++/v1/streambuf b/third_party/libcxx/include/c++/v1/streambuf new file mode 100644 index 0000000..978ecb3 --- /dev/null +++ b/third_party/libcxx/include/c++/v1/streambuf @@ -0,0 +1,445 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_STREAMBUF +#define _LIBCPP_STREAMBUF + +/* + streambuf synopsis + +namespace std +{ + +template <class charT, class traits = char_traits<charT> > +class basic_streambuf +{ +public: + // types: + typedef charT char_type; + typedef traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + virtual ~basic_streambuf(); + + // 27.6.2.2.1 locales: + locale pubimbue(const locale& loc); + locale getloc() const; + + // 27.6.2.2.2 buffer and positioning: + basic_streambuf* pubsetbuf(char_type* s, streamsize n); + pos_type pubseekoff(off_type off, ios_base::seekdir way, + ios_base::openmode which = ios_base::in | ios_base::out); + pos_type pubseekpos(pos_type sp, + ios_base::openmode which = ios_base::in | ios_base::out); + int pubsync(); + + // Get and put areas: + // 27.6.2.2.3 Get area: + streamsize in_avail(); + int_type snextc(); + int_type sbumpc(); + int_type sgetc(); + streamsize sgetn(char_type* s, streamsize n); + + // 27.6.2.2.4 Putback: + int_type sputbackc(char_type c); + int_type sungetc(); + + // 27.6.2.2.5 Put area: + int_type sputc(char_type c); + streamsize sputn(const char_type* s, streamsize n); + +protected: + basic_streambuf(); + basic_streambuf(const basic_streambuf& rhs); + basic_streambuf& operator=(const basic_streambuf& rhs); + void swap(basic_streambuf& rhs); + + // 27.6.2.3.2 Get area: + char_type* eback() const; + char_type* gptr() const; + char_type* egptr() const; + void gbump(int n); + void setg(char_type* gbeg, char_type* gnext, char_type* gend); + + // 27.6.2.3.3 Put area: + char_type* pbase() const; + char_type* pptr() const; + char_type* epptr() const; + void pbump(int n); + void setp(char_type* pbeg, char_type* pend); + + // 27.6.2.4 virtual functions: + // 27.6.2.4.1 Locales: + virtual void imbue(const locale& loc); + + // 27.6.2.4.2 Buffer management and positioning: + virtual basic_streambuf* setbuf(char_type* s, streamsize n); + virtual pos_type seekoff(off_type off, ios_base::seekdir way, + ios_base::openmode which = ios_base::in | ios_base::out); + virtual pos_type seekpos(pos_type sp, + ios_base::openmode which = ios_base::in | ios_base::out); + virtual int sync(); + + // 27.6.2.4.3 Get area: + virtual streamsize showmanyc(); + virtual streamsize xsgetn(char_type* s, streamsize n); + virtual int_type underflow(); + virtual int_type uflow(); + + // 27.6.2.4.4 Putback: + virtual int_type pbackfail(int_type c = traits_type::eof()); + + // 27.6.2.4.5 Put area: + virtual streamsize xsputn(const char_type* s, streamsize n); + virtual int_type overflow (int_type c = traits_type::eof()); +}; + +} // std + +*/ + +#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) +# include <__cxx03/streambuf> +#else +# include <__config> + +# if _LIBCPP_HAS_LOCALIZATION + +# include <__assert> +# include <__fwd/streambuf.h> +# include <__locale> +# include <__memory/valid_range.h> +# include <__type_traits/is_same.h> +# include <__utility/scope_guard.h> +# include <climits> +# include <ios> +# include <iosfwd> +# include <version> + +# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +# endif + +_LIBCPP_PUSH_MACROS +# include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _CharT, class _Traits> +class basic_streambuf { +public: + // types: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + static_assert(is_same<_CharT, typename traits_type::char_type>::value, + "traits_type::char_type must be the same type as CharT"); + + virtual ~basic_streambuf() {} + + // 27.6.2.2.1 locales: + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 locale pubimbue(const locale& __loc) { + imbue(__loc); + locale __r = __loc_; + __loc_ = __loc; + return __r; + } + + [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 locale getloc() const { return __loc_; } + + // 27.6.2.2.2 buffer and positioning: + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_streambuf* pubsetbuf(char_type* __s, streamsize __n) { + return setbuf(__s, __n); + } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 pos_type + pubseekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) { + return seekoff(__off, __way, __which); + } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 pos_type + pubseekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) { + return seekpos(__sp, __which); + } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int pubsync() { return sync(); } + + // Get and put areas: + // 27.6.2.2.3 Get area: + [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 streamsize in_avail() { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (gptr() < egptr()) + return static_cast<streamsize>(egptr() - gptr()); + return showmanyc(); + } + + [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type snextc() { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (sbumpc() == traits_type::eof()) + return traits_type::eof(); + return sgetc(); + } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sbumpc() { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (gptr() == egptr()) + return uflow(); + int_type __c = traits_type::to_int_type(*gptr()); + this->gbump(1); + return __c; + } + + [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sgetc() { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (gptr() == egptr()) + return underflow(); + return traits_type::to_int_type(*gptr()); + } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 streamsize sgetn(char_type* __s, streamsize __n) { return xsgetn(__s, __n); } + + // 27.6.2.2.4 Putback: + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sputbackc(char_type __c) { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (eback() == gptr() || !traits_type::eq(__c, *(gptr() - 1))) + return pbackfail(traits_type::to_int_type(__c)); + this->gbump(-1); + return traits_type::to_int_type(*gptr()); + } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sungetc() { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (eback() == gptr()) + return pbackfail(); + this->gbump(-1); + return traits_type::to_int_type(*gptr()); + } + + // 27.6.2.2.5 Put area: + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sputc(char_type __c) { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (pptr() == epptr()) + return overflow(traits_type::to_int_type(__c)); + *pptr() = __c; + this->pbump(1); + return traits_type::to_int_type(__c); + } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 streamsize sputn(const char_type* __s, streamsize __n) { + return xsputn(__s, __n); + } + +protected: + basic_streambuf() {} + basic_streambuf(const basic_streambuf& __sb) + : __loc_(__sb.__loc_), + __binp_(__sb.__binp_), + __ninp_(__sb.__ninp_), + __einp_(__sb.__einp_), + __bout_(__sb.__bout_), + __nout_(__sb.__nout_), + __eout_(__sb.__eout_) {} + + basic_streambuf& operator=(const basic_streambuf& __sb) { + __loc_ = __sb.__loc_; + __binp_ = __sb.__binp_; + __ninp_ = __sb.__ninp_; + __einp_ = __sb.__einp_; + __bout_ = __sb.__bout_; + __nout_ = __sb.__nout_; + __eout_ = __sb.__eout_; + return *this; + } + + void swap(basic_streambuf& __sb) { + std::swap(__loc_, __sb.__loc_); + std::swap(__binp_, __sb.__binp_); + std::swap(__ninp_, __sb.__ninp_); + std::swap(__einp_, __sb.__einp_); + std::swap(__bout_, __sb.__bout_); + std::swap(__nout_, __sb.__nout_); + std::swap(__eout_, __sb.__eout_); + } + + // 27.6.2.3.2 Get area: + _LIBCPP_HIDE_FROM_ABI char_type* eback() const { return __binp_; } + _LIBCPP_HIDE_FROM_ABI char_type* gptr() const { return __ninp_; } + _LIBCPP_HIDE_FROM_ABI char_type* egptr() const { return __einp_; } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void gbump(int __n) { __ninp_ += __n; } + + // gbump takes an int, so it might not be able to represent the offset we want to add. + _LIBCPP_HIDE_FROM_ABI void __gbump_ptrdiff(ptrdiff_t __n) { __ninp_ += __n; } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) { + _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gnext), "[gbeg, gnext) must be a valid range"); + _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gend), "[gbeg, gend) must be a valid range"); + _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gnext, __gend), "[gnext, gend) must be a valid range"); + __binp_ = __gbeg; + __ninp_ = __gnext; + __einp_ = __gend; + } + + // 27.6.2.3.3 Put area: + _LIBCPP_HIDE_FROM_ABI char_type* pbase() const { return __bout_; } + _LIBCPP_HIDE_FROM_ABI char_type* pptr() const { return __nout_; } + _LIBCPP_HIDE_FROM_ABI char_type* epptr() const { return __eout_; } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void pbump(int __n) { __nout_ += __n; } + + _LIBCPP_HIDE_FROM_ABI void __pbump(streamsize __n) { __nout_ += __n; } + + inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void setp(char_type* __pbeg, char_type* __pend) { + _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__pbeg, __pend), "[pbeg, pend) must be a valid range"); + __bout_ = __nout_ = __pbeg; + __eout_ = __pend; + } + + // 27.6.2.4 virtual functions: + // 27.6.2.4.1 Locales: + virtual void imbue(const locale&) {} + + // 27.6.2.4.2 Buffer management and positioning: + virtual basic_streambuf* setbuf(char_type*, streamsize) { return this; } + virtual pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out) { + return pos_type(off_type(-1)); + } + virtual pos_type seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out) { + return pos_type(off_type(-1)); + } + virtual int sync() { return 0; } + + // 27.6.2.4.3 Get area: + virtual streamsize showmanyc() { return 0; } + + virtual streamsize xsgetn(char_type* __s, streamsize __n) { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + int_type __c; + streamsize __i = 0; + while (__i < __n) { + if (gptr() < egptr()) { + const streamsize __len = std::min(static_cast<streamsize>(INT_MAX), std::min(egptr() - gptr(), __n - __i)); + traits_type::copy(__s, gptr(), __len); + __s += __len; + __i += __len; + this->gbump(__len); + } else if ((__c = uflow()) != traits_type::eof()) { + *__s = traits_type::to_char_type(__c); + ++__s; + ++__i; + } else + break; + } + return __i; + } + + virtual int_type underflow() { return traits_type::eof(); } + virtual int_type uflow() { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + if (underflow() == traits_type::eof()) + return traits_type::eof(); + int_type __c = traits_type::to_int_type(*gptr()); + this->gbump(1); + return __c; + } + + // 27.6.2.4.4 Putback: + virtual int_type pbackfail(int_type = traits_type::eof()) { return traits_type::eof(); } + + // 27.6.2.4.5 Put area: + virtual streamsize xsputn(const char_type* __s, streamsize __n) { + __check_invariants(); + auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); }); + + streamsize __i = 0; + while (__i < __n) { + if (pptr() >= epptr()) { + if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof()) + break; + ++__s; + ++__i; + } else { + streamsize __chunk_size = std::min(epptr() - pptr(), __n - __i); + traits_type::copy(pptr(), __s, __chunk_size); + __pbump(__chunk_size); + __s += __chunk_size; + __i += __chunk_size; + } + } + return __i; + } + + virtual int_type overflow(int_type = traits_type::eof()) { return traits_type::eof(); } + + // This function checks some invariants of the class (it isn't exhaustive). + _LIBCPP_HIDE_FROM_ABI void __check_invariants() const { + _LIBCPP_ASSERT_INTERNAL(pbase() <= pptr(), "this is an invariant of the class"); + _LIBCPP_ASSERT_INTERNAL(pptr() <= epptr(), "this is an invariant of the class"); + + _LIBCPP_ASSERT_INTERNAL(eback() <= gptr(), "this is an invariant of the class"); + _LIBCPP_ASSERT_INTERNAL(gptr() <= egptr(), "this is an invariant of the class"); + } + +private: + locale __loc_; + char_type* __binp_ = nullptr; + char_type* __ninp_ = nullptr; + char_type* __einp_ = nullptr; + char_type* __bout_ = nullptr; + char_type* __nout_ = nullptr; + char_type* __eout_ = nullptr; + + template <class _CharT2, class _Traits2, class _Allocator> + _LIBCPP_HIDE_FROM_ABI friend basic_istream<_CharT2, _Traits2>& + getline(basic_istream<_CharT2, _Traits2>&, basic_string<_CharT2, _Traits2, _Allocator>&, _CharT2); +}; + +extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<char>; + +# if _LIBCPP_HAS_WIDE_CHARACTERS +extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<wchar_t>; +# endif + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +# endif // _LIBCPP_HAS_LOCALIZATION + +# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 +# include <cstdint> +# include <optional> +# endif +#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS) + +#endif // _LIBCPP_STREAMBUF |