Coverage Report

Created: 2020-02-15 09:57

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