1 | //===------------------------ strstream.cpp -------------------------------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | |
9 | #include "strstream" |
10 | #include "algorithm" |
11 | #include "climits" |
12 | #include "cstring" |
13 | #include "cstdlib" |
14 | #include "__debug" |
15 | #include "__undef_macros" |
16 | |
17 | _LIBCPP_BEGIN_NAMESPACE_STD |
18 | |
19 | strstreambuf::strstreambuf(streamsize __alsize) |
20 | : __strmode_(__dynamic), |
21 | __alsize_(__alsize), |
22 | __palloc_(nullptr), |
23 | __pfree_(nullptr) |
24 | { |
25 | } |
26 | |
27 | strstreambuf::strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*)) |
28 | : __strmode_(__dynamic), |
29 | __alsize_(__default_alsize), |
30 | __palloc_(__palloc), |
31 | __pfree_(__pfree) |
32 | { |
33 | } |
34 | |
35 | void |
36 | strstreambuf::__init(char* __gnext, streamsize __n, char* __pbeg) |
37 | { |
38 | if (__n == 0) |
39 | __n = static_cast<streamsize>(strlen(__gnext)); |
40 | else if (__n < 0) |
41 | __n = INT_MAX; |
42 | if (__pbeg == nullptr) |
43 | setg(__gnext, __gnext, __gnext + __n); |
44 | else |
45 | { |
46 | setg(__gnext, __gnext, __pbeg); |
47 | setp(__pbeg, __pbeg + __n); |
48 | } |
49 | } |
50 | |
51 | strstreambuf::strstreambuf(char* __gnext, streamsize __n, char* __pbeg) |
52 | : __strmode_(), |
53 | __alsize_(__default_alsize), |
54 | __palloc_(nullptr), |
55 | __pfree_(nullptr) |
56 | { |
57 | __init(__gnext, __n, __pbeg); |
58 | } |
59 | |
60 | strstreambuf::strstreambuf(const char* __gnext, streamsize __n) |
61 | : __strmode_(__constant), |
62 | __alsize_(__default_alsize), |
63 | __palloc_(nullptr), |
64 | __pfree_(nullptr) |
65 | { |
66 | __init(const_cast<char *>(__gnext), __n, nullptr); |
67 | } |
68 | |
69 | strstreambuf::strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg) |
70 | : __strmode_(), |
71 | __alsize_(__default_alsize), |
72 | __palloc_(nullptr), |
73 | __pfree_(nullptr) |
74 | { |
75 | __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg)); |
76 | } |
77 | |
78 | strstreambuf::strstreambuf(const signed char* __gnext, streamsize __n) |
79 | : __strmode_(__constant), |
80 | __alsize_(__default_alsize), |
81 | __palloc_(nullptr), |
82 | __pfree_(nullptr) |
83 | { |
84 | __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, nullptr); |
85 | } |
86 | |
87 | strstreambuf::strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg) |
88 | : __strmode_(), |
89 | __alsize_(__default_alsize), |
90 | __palloc_(nullptr), |
91 | __pfree_(nullptr) |
92 | { |
93 | __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg)); |
94 | } |
95 | |
96 | strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n) |
97 | : __strmode_(__constant), |
98 | __alsize_(__default_alsize), |
99 | __palloc_(nullptr), |
100 | __pfree_(nullptr) |
101 | { |
102 | __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, nullptr); |
103 | } |
104 | |
105 | strstreambuf::~strstreambuf() |
106 | { |
107 | if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) |
108 | { |
109 | if (__pfree_) |
110 | __pfree_(eback()); |
111 | else |
112 | delete [] eback(); |
113 | } |
114 | } |
115 | |
116 | void |
117 | strstreambuf::swap(strstreambuf& __rhs) |
118 | { |
119 | streambuf::swap(__rhs); |
120 | _VSTD::swap(__strmode_, __rhs.__strmode_); |
121 | _VSTD::swap(__alsize_, __rhs.__alsize_); |
122 | _VSTD::swap(__palloc_, __rhs.__palloc_); |
123 | _VSTD::swap(__pfree_, __rhs.__pfree_); |
124 | } |
125 | |
126 | void |
127 | strstreambuf::freeze(bool __freezefl) |
128 | { |
129 | if (__strmode_ & __dynamic) |
130 | { |
131 | if (__freezefl) |
132 | __strmode_ |= __frozen; |
133 | else |
134 | __strmode_ &= ~__frozen; |
135 | } |
136 | } |
137 | |
138 | char* |
139 | strstreambuf::str() |
140 | { |
141 | if (__strmode_ & __dynamic) |
142 | __strmode_ |= __frozen; |
143 | return eback(); |
144 | } |
145 | |
146 | int |
147 | strstreambuf::pcount() const |
148 | { |
149 | return static_cast<int>(pptr() - pbase()); |
150 | } |
151 | |
152 | strstreambuf::int_type |
153 | strstreambuf::overflow(int_type __c) |
154 | { |
155 | if (__c == EOF) |
156 | return int_type(0); |
157 | if (pptr() == epptr()) |
158 | { |
159 | if ((__strmode_ & __dynamic) == 0 || (__strmode_ & __frozen) != 0) |
160 | return int_type(EOF); |
161 | size_t old_size = static_cast<size_t> ((epptr() ? epptr() : egptr()) - eback()); |
162 | size_t new_size = max<size_t>(static_cast<size_t>(__alsize_), 2*old_size); |
163 | if (new_size == 0) |
164 | new_size = __default_alsize; |
165 | char* buf = nullptr; |
166 | if (__palloc_) |
167 | buf = static_cast<char*>(__palloc_(new_size)); |
168 | else |
169 | buf = new char[new_size]; |
170 | if (buf == nullptr) |
171 | return int_type(EOF); |
172 | if (old_size != 0) { |
173 | _LIBCPP_ASSERT(eback(), "overflow copying from NULL" ); |
174 | memcpy(buf, eback(), static_cast<size_t>(old_size)); |
175 | } |
176 | ptrdiff_t ninp = gptr() - eback(); |
177 | ptrdiff_t einp = egptr() - eback(); |
178 | ptrdiff_t nout = pptr() - pbase(); |
179 | if (__strmode_ & __allocated) |
180 | { |
181 | if (__pfree_) |
182 | __pfree_(eback()); |
183 | else |
184 | delete [] eback(); |
185 | } |
186 | setg(buf, buf + ninp, buf + einp); |
187 | setp(buf + einp, buf + new_size); |
188 | __pbump(nout); |
189 | __strmode_ |= __allocated; |
190 | } |
191 | *pptr() = static_cast<char>(__c); |
192 | pbump(1); |
193 | return int_type(static_cast<unsigned char>(__c)); |
194 | } |
195 | |
196 | strstreambuf::int_type |
197 | strstreambuf::pbackfail(int_type __c) |
198 | { |
199 | if (eback() == gptr()) |
200 | return EOF; |
201 | if (__c == EOF) |
202 | { |
203 | gbump(-1); |
204 | return int_type(0); |
205 | } |
206 | if (__strmode_ & __constant) |
207 | { |
208 | if (gptr()[-1] == static_cast<char>(__c)) |
209 | { |
210 | gbump(-1); |
211 | return __c; |
212 | } |
213 | return EOF; |
214 | } |
215 | gbump(-1); |
216 | *gptr() = static_cast<char>(__c); |
217 | return __c; |
218 | } |
219 | |
220 | strstreambuf::int_type |
221 | strstreambuf::underflow() |
222 | { |
223 | if (gptr() == egptr()) |
224 | { |
225 | if (egptr() >= pptr()) |
226 | return EOF; |
227 | setg(eback(), gptr(), pptr()); |
228 | } |
229 | return int_type(static_cast<unsigned char>(*gptr())); |
230 | } |
231 | |
232 | strstreambuf::pos_type |
233 | strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which) |
234 | { |
235 | off_type __p(-1); |
236 | bool pos_in = (__which & ios::in) != 0; |
237 | bool pos_out = (__which & ios::out) != 0; |
238 | bool legal = false; |
239 | switch (__way) |
240 | { |
241 | case ios::beg: |
242 | case ios::end: |
243 | if (pos_in || pos_out) |
244 | legal = true; |
245 | break; |
246 | case ios::cur: |
247 | if (pos_in != pos_out) |
248 | legal = true; |
249 | break; |
250 | } |
251 | if (pos_in && gptr() == nullptr) |
252 | legal = false; |
253 | if (pos_out && pptr() == nullptr) |
254 | legal = false; |
255 | if (legal) |
256 | { |
257 | off_type newoff; |
258 | char* seekhigh = epptr() ? epptr() : egptr(); |
259 | switch (__way) |
260 | { |
261 | case ios::beg: |
262 | newoff = 0; |
263 | break; |
264 | case ios::cur: |
265 | newoff = (pos_in ? gptr() : pptr()) - eback(); |
266 | break; |
267 | case ios::end: |
268 | newoff = seekhigh - eback(); |
269 | break; |
270 | default: |
271 | _LIBCPP_UNREACHABLE(); |
272 | } |
273 | newoff += __off; |
274 | if (0 <= newoff && newoff <= seekhigh - eback()) |
275 | { |
276 | char* newpos = eback() + newoff; |
277 | if (pos_in) |
278 | setg(eback(), newpos, _VSTD::max(newpos, egptr())); |
279 | if (pos_out) |
280 | { |
281 | // min(pbase, newpos), newpos, epptr() |
282 | __off = epptr() - newpos; |
283 | setp(min(pbase(), newpos), epptr()); |
284 | __pbump((epptr() - pbase()) - __off); |
285 | } |
286 | __p = newoff; |
287 | } |
288 | } |
289 | return pos_type(__p); |
290 | } |
291 | |
292 | strstreambuf::pos_type |
293 | strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which) |
294 | { |
295 | off_type __p(-1); |
296 | bool pos_in = (__which & ios::in) != 0; |
297 | bool pos_out = (__which & ios::out) != 0; |
298 | if (pos_in || pos_out) |
299 | { |
300 | if (!((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr))) |
301 | { |
302 | off_type newoff = __sp; |
303 | char* seekhigh = epptr() ? epptr() : egptr(); |
304 | if (0 <= newoff && newoff <= seekhigh - eback()) |
305 | { |
306 | char* newpos = eback() + newoff; |
307 | if (pos_in) |
308 | setg(eback(), newpos, _VSTD::max(newpos, egptr())); |
309 | if (pos_out) |
310 | { |
311 | // min(pbase, newpos), newpos, epptr() |
312 | off_type temp = epptr() - newpos; |
313 | setp(min(pbase(), newpos), epptr()); |
314 | __pbump((epptr() - pbase()) - temp); |
315 | } |
316 | __p = newoff; |
317 | } |
318 | } |
319 | } |
320 | return pos_type(__p); |
321 | } |
322 | |
323 | istrstream::~istrstream() |
324 | { |
325 | } |
326 | |
327 | ostrstream::~ostrstream() |
328 | { |
329 | } |
330 | |
331 | strstream::~strstream() |
332 | { |
333 | } |
334 | |
335 | _LIBCPP_END_NAMESPACE_STD |
336 | |