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