| // -*- 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_STRSTREAM |
| #define _LIBCPP_STRSTREAM |
| |
| /* |
| strstream synopsis |
| |
| class strstreambuf // Removed in C++26 |
| : public basic_streambuf<char> |
| { |
| public: |
| explicit strstreambuf(streamsize alsize_arg = 0); // before C++20 |
| strstreambuf() : strstreambuf(0) {} // C++20 |
| explicit strstreambuf(streamsize alsize_arg); // C++20 |
| |
| strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*)); |
| strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr); |
| strstreambuf(const char* gnext_arg, streamsize n); |
| |
| strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = nullptr); |
| strstreambuf(const signed char* gnext_arg, streamsize n); |
| strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = nullptr); |
| strstreambuf(const unsigned char* gnext_arg, streamsize n); |
| |
| strstreambuf(strstreambuf&& rhs); |
| strstreambuf& operator=(strstreambuf&& rhs); |
| |
| virtual ~strstreambuf(); |
| |
| void swap(strstreambuf& rhs); |
| |
| void freeze(bool freezefl = true); |
| char* str(); |
| int pcount() const; |
| |
| protected: |
| virtual int_type overflow (int_type c = EOF); |
| virtual int_type pbackfail(int_type c = EOF); |
| virtual int_type underflow(); |
| 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 streambuf* setbuf(char* s, streamsize n); |
| |
| private: |
| typedef T1 strstate; // exposition only |
| static const strstate allocated; // exposition only |
| static const strstate constant; // exposition only |
| static const strstate dynamic; // exposition only |
| static const strstate frozen; // exposition only |
| strstate strmode; // exposition only |
| streamsize alsize; // exposition only |
| void* (*palloc)(size_t); // exposition only |
| void (*pfree)(void*); // exposition only |
| }; |
| |
| class istrstream // Removed in C++26 |
| : public basic_istream<char> |
| { |
| public: |
| explicit istrstream(const char* s); |
| explicit istrstream(char* s); |
| istrstream(const char* s, streamsize n); |
| istrstream(char* s, streamsize n); |
| |
| virtual ~istrstream(); |
| |
| strstreambuf* rdbuf() const; |
| char *str(); |
| |
| private: |
| strstreambuf sb; // exposition only |
| }; |
| |
| class ostrstream // Removed in C++26 |
| : public basic_ostream<char> |
| { |
| public: |
| ostrstream(); |
| ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out); |
| |
| virtual ~ostrstream(); |
| |
| strstreambuf* rdbuf() const; |
| void freeze(bool freezefl = true); |
| char* str(); |
| int pcount() const; |
| |
| private: |
| strstreambuf sb; // exposition only |
| }; |
| |
| class strstream // Removed in C++26 |
| : public basic_iostream<char> |
| { |
| public: |
| // Types |
| typedef char char_type; |
| typedef char_traits<char>::int_type int_type; |
| typedef char_traits<char>::pos_type pos_type; |
| typedef char_traits<char>::off_type off_type; |
| |
| // constructors/destructor |
| strstream(); |
| strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out); |
| |
| virtual ~strstream(); |
| |
| // Members: |
| strstreambuf* rdbuf() const; |
| void freeze(bool freezefl = true); |
| int pcount() const; |
| char* str(); |
| |
| private: |
| strstreambuf sb; // exposition only |
| }; |
| |
| } // std |
| |
| */ |
| |
| #include <__config> |
| #include <istream> |
| #include <ostream> |
| #include <version> |
| |
| #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| # pragma GCC system_header |
| #endif |
| |
| #if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY) |
| |
| _LIBCPP_PUSH_MACROS |
| # include <__undef_macros> |
| |
| _LIBCPP_BEGIN_NAMESPACE_STD |
| |
| class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstreambuf : public streambuf { |
| public: |
| # ifndef _LIBCPP_CXX03_LANG |
| _LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {} |
| explicit strstreambuf(streamsize __alsize); |
| # else |
| explicit strstreambuf(streamsize __alsize = 0); |
| # endif |
| strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*)); |
| strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr); |
| strstreambuf(const char* __gnext, streamsize __n); |
| |
| strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr); |
| strstreambuf(const signed char* __gnext, streamsize __n); |
| strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr); |
| strstreambuf(const unsigned char* __gnext, streamsize __n); |
| |
| # ifndef _LIBCPP_CXX03_LANG |
| _LIBCPP_HIDE_FROM_ABI strstreambuf(strstreambuf&& __rhs); |
| _LIBCPP_HIDE_FROM_ABI strstreambuf& operator=(strstreambuf&& __rhs); |
| # endif // _LIBCPP_CXX03_LANG |
| |
| ~strstreambuf() override; |
| |
| void swap(strstreambuf& __rhs); |
| |
| void freeze(bool __freezefl = true); |
| char* str(); |
| int pcount() const; |
| |
| protected: |
| int_type overflow(int_type __c = EOF) override; |
| int_type pbackfail(int_type __c = EOF) override; |
| int_type underflow() override; |
| pos_type |
| seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) override; |
| pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) override; |
| |
| private: |
| typedef unsigned __mode_type; |
| static const __mode_type __allocated = 0x01; |
| static const __mode_type __constant = 0x02; |
| static const __mode_type __dynamic = 0x04; |
| static const __mode_type __frozen = 0x08; |
| static const streamsize __default_alsize = 4096; |
| |
| __mode_type __strmode_; |
| streamsize __alsize_; |
| void* (*__palloc_)(size_t); |
| void (*__pfree_)(void*); |
| |
| void __init(char* __gnext, streamsize __n, char* __pbeg); |
| }; |
| |
| # ifndef _LIBCPP_CXX03_LANG |
| |
| inline _LIBCPP_HIDE_FROM_ABI strstreambuf::strstreambuf(strstreambuf&& __rhs) |
| : streambuf(__rhs), |
| __strmode_(__rhs.__strmode_), |
| __alsize_(__rhs.__alsize_), |
| __palloc_(__rhs.__palloc_), |
| __pfree_(__rhs.__pfree_) { |
| __rhs.setg(nullptr, nullptr, nullptr); |
| __rhs.setp(nullptr, nullptr); |
| } |
| |
| inline _LIBCPP_HIDE_FROM_ABI strstreambuf& strstreambuf::operator=(strstreambuf&& __rhs) { |
| if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) { |
| if (__pfree_) |
| __pfree_(eback()); |
| else |
| delete[] eback(); |
| } |
| streambuf::operator=(__rhs); |
| __strmode_ = __rhs.__strmode_; |
| __alsize_ = __rhs.__alsize_; |
| __palloc_ = __rhs.__palloc_; |
| __pfree_ = __rhs.__pfree_; |
| __rhs.setg(nullptr, nullptr, nullptr); |
| __rhs.setp(nullptr, nullptr); |
| return *this; |
| } |
| |
| # endif // _LIBCPP_CXX03_LANG |
| |
| class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI istrstream : public istream { |
| public: |
| _LIBCPP_HIDE_FROM_ABI explicit istrstream(const char* __s) : istream(&__sb_), __sb_(__s, 0) {} |
| _LIBCPP_HIDE_FROM_ABI explicit istrstream(char* __s) : istream(&__sb_), __sb_(__s, 0) {} |
| _LIBCPP_HIDE_FROM_ABI istrstream(const char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {} |
| _LIBCPP_HIDE_FROM_ABI istrstream(char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {} |
| |
| # ifndef _LIBCPP_CXX03_LANG |
| _LIBCPP_HIDE_FROM_ABI istrstream(istrstream&& __rhs) // extension |
| : istream(std::move(static_cast<istream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) { |
| istream::set_rdbuf(&__sb_); |
| } |
| |
| _LIBCPP_HIDE_FROM_ABI istrstream& operator=(istrstream&& __rhs) { |
| __sb_ = std::move(__rhs.__sb_); |
| istream::operator=(std::move(__rhs)); |
| return *this; |
| } |
| # endif // _LIBCPP_CXX03_LANG |
| |
| ~istrstream() override; |
| |
| _LIBCPP_HIDE_FROM_ABI void swap(istrstream& __rhs) { |
| istream::swap(__rhs); |
| __sb_.swap(__rhs.__sb_); |
| } |
| |
| _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); } |
| _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); } |
| |
| private: |
| strstreambuf __sb_; |
| }; |
| |
| class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI ostrstream : public ostream { |
| public: |
| _LIBCPP_HIDE_FROM_ABI ostrstream() : ostream(&__sb_) {} |
| _LIBCPP_HIDE_FROM_ABI ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out) |
| : ostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {} |
| |
| # ifndef _LIBCPP_CXX03_LANG |
| _LIBCPP_HIDE_FROM_ABI ostrstream(ostrstream&& __rhs) // extension |
| : ostream(std::move(static_cast<ostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) { |
| ostream::set_rdbuf(&__sb_); |
| } |
| |
| _LIBCPP_HIDE_FROM_ABI ostrstream& operator=(ostrstream&& __rhs) { |
| __sb_ = std::move(__rhs.__sb_); |
| ostream::operator=(std::move(__rhs)); |
| return *this; |
| } |
| # endif // _LIBCPP_CXX03_LANG |
| |
| ~ostrstream() override; |
| |
| _LIBCPP_HIDE_FROM_ABI void swap(ostrstream& __rhs) { |
| ostream::swap(__rhs); |
| __sb_.swap(__rhs.__sb_); |
| } |
| |
| _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); } |
| _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); } |
| _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); } |
| _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); } |
| |
| private: |
| strstreambuf __sb_; // exposition only |
| }; |
| |
| class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstream : public iostream { |
| public: |
| // Types |
| typedef char char_type; |
| typedef char_traits<char>::int_type int_type; |
| typedef char_traits<char>::pos_type pos_type; |
| typedef char_traits<char>::off_type off_type; |
| |
| // constructors/destructor |
| _LIBCPP_HIDE_FROM_ABI strstream() : iostream(&__sb_) {} |
| _LIBCPP_HIDE_FROM_ABI strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out) |
| : iostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {} |
| |
| # ifndef _LIBCPP_CXX03_LANG |
| _LIBCPP_HIDE_FROM_ABI strstream(strstream&& __rhs) // extension |
| : iostream(std::move(static_cast<iostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) { |
| iostream::set_rdbuf(&__sb_); |
| } |
| |
| _LIBCPP_HIDE_FROM_ABI strstream& operator=(strstream&& __rhs) { |
| __sb_ = std::move(__rhs.__sb_); |
| iostream::operator=(std::move(__rhs)); |
| return *this; |
| } |
| # endif // _LIBCPP_CXX03_LANG |
| |
| ~strstream() override; |
| |
| _LIBCPP_HIDE_FROM_ABI void swap(strstream& __rhs) { |
| iostream::swap(__rhs); |
| __sb_.swap(__rhs.__sb_); |
| } |
| |
| // Members: |
| _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); } |
| _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); } |
| _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); } |
| _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); } |
| |
| private: |
| strstreambuf __sb_; // exposition only |
| }; |
| |
| _LIBCPP_END_NAMESPACE_STD |
| |
| _LIBCPP_POP_MACROS |
| |
| #endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY) |
| |
| #endif // _LIBCPP_STRSTREAM |