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_STRSTREAM
11#define _LIBCPP_STRSTREAM
12
13/*
14    strstream synopsis
15
16class strstreambuf
17    : public basic_streambuf<char>
18{
19public:
20    explicit strstreambuf(streamsize alsize_arg = 0); // before C++20
21    strstreambuf() : strstreambuf(0) {}               // C++20
22    explicit strstreambuf(streamsize alsize_arg);     // C++20
23
24    strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
25    strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);
26    strstreambuf(const char* gnext_arg, streamsize n);
27
28    strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = nullptr);
29    strstreambuf(const signed char* gnext_arg, streamsize n);
30    strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = nullptr);
31    strstreambuf(const unsigned char* gnext_arg, streamsize n);
32
33    strstreambuf(strstreambuf&& rhs);
34    strstreambuf& operator=(strstreambuf&& rhs);
35
36    virtual ~strstreambuf();
37
38    void swap(strstreambuf& rhs);
39
40    void freeze(bool freezefl = true);
41    char* str();
42    int pcount() const;
43
44protected:
45    virtual int_type overflow (int_type c = EOF);
46    virtual int_type pbackfail(int_type c = EOF);
47    virtual int_type underflow();
48    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
49                             ios_base::openmode which = ios_base::in | ios_base::out);
50    virtual pos_type seekpos(pos_type sp,
51                             ios_base::openmode which = ios_base::in | ios_base::out);
52    virtual streambuf* setbuf(char* s, streamsize n);
53
54private:
55    typedef T1 strstate;                // exposition only
56    static const strstate allocated;    // exposition only
57    static const strstate constant;     // exposition only
58    static const strstate dynamic;      // exposition only
59    static const strstate frozen;       // exposition only
60    strstate strmode;                   // exposition only
61    streamsize alsize;                  // exposition only
62    void* (*palloc)(size_t);            // exposition only
63    void (*pfree)(void*);               // exposition only
64};
65
66class istrstream
67    : public basic_istream<char>
68{
69public:
70    explicit istrstream(const char* s);
71    explicit istrstream(char* s);
72    istrstream(const char* s, streamsize n);
73    istrstream(char* s, streamsize n);
74
75    virtual ~istrstream();
76
77    strstreambuf* rdbuf() const;
78    char *str();
79
80private:
81    strstreambuf sb; // exposition only
82};
83
84class ostrstream
85    : public basic_ostream<char>
86{
87public:
88    ostrstream();
89    ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);
90
91    virtual ~ostrstream();
92
93    strstreambuf* rdbuf() const;
94    void freeze(bool freezefl = true);
95    char* str();
96    int pcount() const;
97
98private:
99    strstreambuf sb; // exposition only
100};
101
102class strstream
103    : public basic_iostream<char>
104{
105public:
106    // Types
107    typedef char                        char_type;
108    typedef char_traits<char>::int_type int_type;
109    typedef char_traits<char>::pos_type pos_type;
110    typedef char_traits<char>::off_type off_type;
111
112    // constructors/destructor
113    strstream();
114    strstream(char* s, int n, ios_base::openmode mode = ios_base::in | ios_base::out);
115
116    virtual ~strstream();
117
118    // Members:
119    strstreambuf* rdbuf() const;
120    void freeze(bool freezefl = true);
121    int pcount() const;
122    char* str();
123
124private:
125    strstreambuf sb; // exposition only
126};
127
128}  // std
129
130*/
131
132#include <__config>
133#include <istream>
134#include <ostream>
135#include <version>
136
137#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
138#  pragma GCC system_header
139#endif
140
141_LIBCPP_PUSH_MACROS
142#include <__undef_macros>
143
144_LIBCPP_BEGIN_NAMESPACE_STD
145
146class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstreambuf : public streambuf {
147public:
148#ifndef _LIBCPP_CXX03_LANG
149  _LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {}
150  explicit strstreambuf(streamsize __alsize);
151#else
152  explicit strstreambuf(streamsize __alsize = 0);
153#endif
154  strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
155  strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);
156  strstreambuf(const char* __gnext, streamsize __n);
157
158  strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);
159  strstreambuf(const signed char* __gnext, streamsize __n);
160  strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);
161  strstreambuf(const unsigned char* __gnext, streamsize __n);
162
163#ifndef _LIBCPP_CXX03_LANG
164  _LIBCPP_HIDE_FROM_ABI strstreambuf(strstreambuf&& __rhs);
165  _LIBCPP_HIDE_FROM_ABI strstreambuf& operator=(strstreambuf&& __rhs);
166#endif // _LIBCPP_CXX03_LANG
167
168  ~strstreambuf() override;
169
170  void swap(strstreambuf& __rhs);
171
172  void freeze(bool __freezefl = true);
173  char* str();
174  int pcount() const;
175
176protected:
177  int_type overflow(int_type __c = EOF) override;
178  int_type pbackfail(int_type __c = EOF) override;
179  int_type underflow() override;
180  pos_type
181  seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) override;
182  pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) override;
183
184private:
185  typedef unsigned __mode_type;
186  static const __mode_type __allocated     = 0x01;
187  static const __mode_type __constant      = 0x02;
188  static const __mode_type __dynamic       = 0x04;
189  static const __mode_type __frozen        = 0x08;
190  static const streamsize __default_alsize = 4096;
191
192  __mode_type __strmode_;
193  streamsize __alsize_;
194  void* (*__palloc_)(size_t);
195  void (*__pfree_)(void*);
196
197  void __init(char* __gnext, streamsize __n, char* __pbeg);
198};
199
200#ifndef _LIBCPP_CXX03_LANG
201
202inline _LIBCPP_HIDE_FROM_ABI strstreambuf::strstreambuf(strstreambuf&& __rhs)
203    : streambuf(__rhs),
204      __strmode_(__rhs.__strmode_),
205      __alsize_(__rhs.__alsize_),
206      __palloc_(__rhs.__palloc_),
207      __pfree_(__rhs.__pfree_) {
208  __rhs.setg(nullptr, nullptr, nullptr);
209  __rhs.setp(nullptr, nullptr);
210}
211
212inline _LIBCPP_HIDE_FROM_ABI strstreambuf& strstreambuf::operator=(strstreambuf&& __rhs) {
213  if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {
214    if (__pfree_)
215      __pfree_(eback());
216    else
217      delete[] eback();
218  }
219  streambuf::operator=(__rhs);
220  __strmode_ = __rhs.__strmode_;
221  __alsize_  = __rhs.__alsize_;
222  __palloc_  = __rhs.__palloc_;
223  __pfree_   = __rhs.__pfree_;
224  __rhs.setg(nullptr, nullptr, nullptr);
225  __rhs.setp(nullptr, nullptr);
226  return *this;
227}
228
229#endif // _LIBCPP_CXX03_LANG
230
231class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI istrstream : public istream {
232public:
233  _LIBCPP_HIDE_FROM_ABI explicit istrstream(const char* __s) : istream(&__sb_), __sb_(__s, 0) {}
234  _LIBCPP_HIDE_FROM_ABI explicit istrstream(char* __s) : istream(&__sb_), __sb_(__s, 0) {}
235  _LIBCPP_HIDE_FROM_ABI istrstream(const char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
236  _LIBCPP_HIDE_FROM_ABI istrstream(char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
237
238#ifndef _LIBCPP_CXX03_LANG
239  _LIBCPP_HIDE_FROM_ABI istrstream(istrstream&& __rhs) // extension
240      : istream(std::move(static_cast<istream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
241    istream::set_rdbuf(&__sb_);
242  }
243
244  _LIBCPP_HIDE_FROM_ABI istrstream& operator=(istrstream&& __rhs) {
245    __sb_ = std::move(__rhs.__sb_);
246    istream::operator=(std::move(__rhs));
247    return *this;
248  }
249#endif // _LIBCPP_CXX03_LANG
250
251  ~istrstream() override;
252
253  _LIBCPP_HIDE_FROM_ABI void swap(istrstream& __rhs) {
254    istream::swap(__rhs);
255    __sb_.swap(__rhs.__sb_);
256  }
257
258  _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
259  _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
260
261private:
262  strstreambuf __sb_;
263};
264
265class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI ostrstream : public ostream {
266public:
267  _LIBCPP_HIDE_FROM_ABI ostrstream() : ostream(&__sb_) {}
268  _LIBCPP_HIDE_FROM_ABI ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
269      : ostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
270
271#ifndef _LIBCPP_CXX03_LANG
272  _LIBCPP_HIDE_FROM_ABI ostrstream(ostrstream&& __rhs) // extension
273      : ostream(std::move(static_cast<ostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
274    ostream::set_rdbuf(&__sb_);
275  }
276
277  _LIBCPP_HIDE_FROM_ABI ostrstream& operator=(ostrstream&& __rhs) {
278    __sb_ = std::move(__rhs.__sb_);
279    ostream::operator=(std::move(__rhs));
280    return *this;
281  }
282#endif // _LIBCPP_CXX03_LANG
283
284  ~ostrstream() override;
285
286  _LIBCPP_HIDE_FROM_ABI void swap(ostrstream& __rhs) {
287    ostream::swap(__rhs);
288    __sb_.swap(__rhs.__sb_);
289  }
290
291  _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
292  _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
293  _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
294  _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
295
296private:
297  strstreambuf __sb_; // exposition only
298};
299
300class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstream : public iostream {
301public:
302  // Types
303  typedef char char_type;
304  typedef char_traits<char>::int_type int_type;
305  typedef char_traits<char>::pos_type pos_type;
306  typedef char_traits<char>::off_type off_type;
307
308  // constructors/destructor
309  _LIBCPP_HIDE_FROM_ABI strstream() : iostream(&__sb_) {}
310  _LIBCPP_HIDE_FROM_ABI strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
311      : iostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
312
313#ifndef _LIBCPP_CXX03_LANG
314  _LIBCPP_HIDE_FROM_ABI strstream(strstream&& __rhs) // extension
315      : iostream(std::move(static_cast<iostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
316    iostream::set_rdbuf(&__sb_);
317  }
318
319  _LIBCPP_HIDE_FROM_ABI strstream& operator=(strstream&& __rhs) {
320    __sb_ = std::move(__rhs.__sb_);
321    iostream::operator=(std::move(__rhs));
322    return *this;
323  }
324#endif // _LIBCPP_CXX03_LANG
325
326  ~strstream() override;
327
328  _LIBCPP_HIDE_FROM_ABI void swap(strstream& __rhs) {
329    iostream::swap(__rhs);
330    __sb_.swap(__rhs.__sb_);
331  }
332
333  // Members:
334  _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
335  _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
336  _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
337  _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
338
339private:
340  strstreambuf __sb_; // exposition only
341};
342
343_LIBCPP_END_NAMESPACE_STD
344
345_LIBCPP_POP_MACROS
346
347#endif // _LIBCPP_STRSTREAM
348