|
1 /* |
|
2 * © Portions copyright (c) 2006-2007 Nokia Corporation. All rights reserved. |
|
3 * |
|
4 * Copyright (c) 1999 |
|
5 * Silicon Graphics Computer Systems, Inc. |
|
6 * |
|
7 * Copyright (c) 1999 |
|
8 * Boris Fomitchev |
|
9 * |
|
10 * This material is provided "as is", with absolutely no warranty expressed |
|
11 * or implied. Any use is at your own risk. |
|
12 * |
|
13 * Permission to use or copy this software for any purpose is hereby granted |
|
14 * without fee, provided the above notices are retained on all copies. |
|
15 * Permission to modify the code and to distribute modified code is granted, |
|
16 * provided the above notices are retained, and a notice that the code was |
|
17 * modified is included with the above copyright notice. |
|
18 * |
|
19 */ |
|
20 |
|
21 // Implementation of the classes in header <strstream>. |
|
22 // WARNING: The classes defined in <strstream> are DEPRECATED. This |
|
23 // header is defined in section D.7.1 of the C++ standard, and it |
|
24 // MAY BE REMOVED in a future standard revision. You should use the |
|
25 // header <sstream> instead. |
|
26 |
|
27 # include "stlport_prefix.h" |
|
28 #include <stl/_strstream.h> |
|
29 #include <stl/_algobase.h> |
|
30 |
|
31 _STLP_BEGIN_NAMESPACE |
|
32 |
|
33 // strstreambuf constructor, destructor. |
|
34 |
|
35 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(streamsize initial_capacity) |
|
36 : _M_alloc_fun(0), _M_free_fun(0), |
|
37 _M_dynamic(true), _M_frozen(false), _M_constant(false) |
|
38 #ifdef __SYMBIAN32__ |
|
39 , _pfrozenendsave(NULL) |
|
40 ,_pgetfrozenendsave( NULL) |
|
41 #endif |
|
42 { |
|
43 streamsize n = (max)(initial_capacity, streamsize(16)); |
|
44 |
|
45 char* buf = _M_alloc(n); |
|
46 #ifdef __SYMBIAN32__ |
|
47 *buf = '\0'; |
|
48 #endif |
|
49 if (buf) { |
|
50 setp(buf, buf + n); |
|
51 setg(buf, buf, buf); |
|
52 } |
|
53 } |
|
54 |
|
55 |
|
56 |
|
57 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(__alloc_fn alloc_f, __free_fn free_f) |
|
58 : _M_alloc_fun(alloc_f), _M_free_fun(free_f), |
|
59 _M_dynamic(true), _M_frozen(false), _M_constant(false) |
|
60 #ifdef __SYMBIAN32__ |
|
61 , _pfrozenendsave(NULL) |
|
62 ,_pgetfrozenendsave( NULL) |
|
63 #endif |
|
64 { |
|
65 streamsize n = 16; |
|
66 #ifndef __SYMBIAN32__ |
|
67 char* buf = _M_alloc(n); |
|
68 #else |
|
69 char* buf = NULL; |
|
70 if(alloc_f!=NULL) |
|
71 buf = (char*)_M_alloc_fun(n); |
|
72 else |
|
73 buf = _M_alloc(n); |
|
74 if(buf) |
|
75 *buf = '\0'; |
|
76 #endif |
|
77 if (buf) { |
|
78 setp(buf, buf + n); |
|
79 setg(buf, buf, buf); |
|
80 } |
|
81 } |
|
82 |
|
83 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(char* get, streamsize n, char* put) |
|
84 : _M_alloc_fun(0), _M_free_fun(0), |
|
85 _M_dynamic(false), _M_frozen(false), _M_constant(false) |
|
86 #ifdef __SYMBIAN32__ |
|
87 , _pfrozenendsave(NULL) |
|
88 ,_pgetfrozenendsave( NULL) |
|
89 #endif |
|
90 { |
|
91 _M_setup(get, put, n); |
|
92 } |
|
93 |
|
94 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(signed char* get, streamsize n, signed char* put) |
|
95 : _M_alloc_fun(0), _M_free_fun(0), |
|
96 _M_dynamic(false), _M_frozen(false), _M_constant(false) |
|
97 #ifdef __SYMBIAN32__ |
|
98 , _pfrozenendsave(NULL) |
|
99 ,_pgetfrozenendsave( NULL) |
|
100 #endif |
|
101 { |
|
102 _M_setup(__REINTERPRET_CAST(char*,get), __REINTERPRET_CAST(char*,put), n); |
|
103 } |
|
104 |
|
105 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(unsigned char* get, streamsize n, |
|
106 unsigned char* put) |
|
107 : _M_alloc_fun(0), _M_free_fun(0), |
|
108 _M_dynamic(false), _M_frozen(false), _M_constant(false) |
|
109 #ifdef __SYMBIAN32__ |
|
110 , _pfrozenendsave(NULL) |
|
111 ,_pgetfrozenendsave( NULL) |
|
112 #endif |
|
113 { |
|
114 _M_setup(__REINTERPRET_CAST(char*,get), __REINTERPRET_CAST(char*,put), n); |
|
115 } |
|
116 |
|
117 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(const char* get, streamsize n) |
|
118 : _M_alloc_fun(0), _M_free_fun(0), |
|
119 _M_dynamic(false), _M_frozen(false), _M_constant(true) |
|
120 #ifdef __SYMBIAN32__ |
|
121 , _pfrozenendsave(NULL) |
|
122 ,_pgetfrozenendsave( NULL) |
|
123 #endif |
|
124 { |
|
125 _M_setup(__CONST_CAST(char*,get), 0, n); |
|
126 } |
|
127 |
|
128 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(const signed char* get, streamsize n) |
|
129 : _M_alloc_fun(0), _M_free_fun(0), |
|
130 _M_dynamic(false), _M_frozen(false), _M_constant(true) |
|
131 #ifdef __SYMBIAN32__ |
|
132 , _pfrozenendsave(NULL) |
|
133 ,_pgetfrozenendsave( NULL) |
|
134 #endif |
|
135 { |
|
136 _M_setup(__REINTERPRET_CAST(char*, __CONST_CAST(signed char*,get)), 0, n); |
|
137 } |
|
138 |
|
139 _STLP_EXP_DECLSPEC strstreambuf::strstreambuf(const unsigned char* get, streamsize n) |
|
140 : _M_alloc_fun(0), _M_free_fun(0), |
|
141 _M_dynamic(false), _M_frozen(false), _M_constant(true) |
|
142 #ifdef __SYMBIAN32__ |
|
143 , _pfrozenendsave(NULL) |
|
144 ,_pgetfrozenendsave( NULL) |
|
145 #endif |
|
146 { |
|
147 _M_setup(__REINTERPRET_CAST(char*, __CONST_CAST(unsigned char*,get)), 0, n); |
|
148 } |
|
149 |
|
150 _STLP_EXP_DECLSPEC void strstreambuf::freeze(bool frozenflag) |
|
151 { |
|
152 #ifdef __SYMBIAN32__ |
|
153 if (_M_dynamic) |
|
154 { |
|
155 // |
|
156 if (frozenflag && !_M_frozen) |
|
157 { // disable writing |
|
158 _M_frozen = frozenflag; |
|
159 _pfrozenendsave = epptr(); |
|
160 _pgetfrozenendsave = pptr(); |
|
161 setp(pbase(), eback()); |
|
162 } |
|
163 else if (!frozenflag && _M_frozen) |
|
164 { // re-enable writing |
|
165 _M_frozen = frozenflag; |
|
166 if(_pfrozenendsave != NULL) |
|
167 { |
|
168 setp(pbase(), _pfrozenendsave); |
|
169 setg(pbase(), pbase(), _pgetfrozenendsave); |
|
170 } |
|
171 } |
|
172 } |
|
173 #else |
|
174 if (_M_dynamic) |
|
175 _M_frozen = frozenflag; |
|
176 #endif |
|
177 } |
|
178 |
|
179 _STLP_EXP_DECLSPEC char* strstreambuf::str() |
|
180 { |
|
181 freeze(true); |
|
182 return eback(); |
|
183 } |
|
184 |
|
185 _STLP_EXP_DECLSPEC int strstreambuf::pcount() const |
|
186 { |
|
187 return int(pptr() ? pptr() - pbase() : 0); |
|
188 } |
|
189 |
|
190 _STLP_EXP_DECLSPEC strstreambuf::int_type strstreambuf::overflow(int_type c) { |
|
191 if (c == traits_type::eof()) |
|
192 return traits_type::not_eof(c); |
|
193 #ifdef __SYMBIAN32__ |
|
194 if (pptr() != 0 && pptr() < epptr()) |
|
195 { |
|
196 *pptr() = c; |
|
197 pbump(1); |
|
198 return c; |
|
199 } |
|
200 if (!_M_dynamic || _M_constant || _M_frozen) |
|
201 return (EOF); // can't extend |
|
202 #endif |
|
203 // Try to expand the buffer. |
|
204 if (pptr() == epptr() && _M_dynamic && !_M_frozen && !_M_constant) { |
|
205 ptrdiff_t old_size = epptr() - pbase(); |
|
206 ptrdiff_t new_size = (max)(2 * old_size, ptrdiff_t(1)); |
|
207 |
|
208 char* buf = _M_alloc(new_size); |
|
209 if (buf) { |
|
210 memcpy(buf, pbase(), old_size); |
|
211 |
|
212 char* old_buffer = pbase(); |
|
213 bool reposition_get = false; |
|
214 ptrdiff_t old_get_offset; |
|
215 if (gptr() != 0) { |
|
216 reposition_get = true; |
|
217 old_get_offset = gptr() - eback(); |
|
218 } |
|
219 |
|
220 setp(buf, buf + new_size); |
|
221 pbump((int)old_size); |
|
222 |
|
223 if (reposition_get) |
|
224 setg(buf, buf + old_get_offset, buf + (max)(old_get_offset, old_size)); |
|
225 |
|
226 _M_free(old_buffer); |
|
227 } |
|
228 } |
|
229 |
|
230 if (pptr() != epptr()) { |
|
231 *pptr() = c; |
|
232 pbump(1); |
|
233 return c; |
|
234 } |
|
235 else |
|
236 return traits_type::eof(); |
|
237 } |
|
238 |
|
239 _STLP_EXP_DECLSPEC strstreambuf::int_type strstreambuf::pbackfail(int_type c) |
|
240 { |
|
241 if (gptr() != eback()) { |
|
242 if (c == _Traits::eof()) { |
|
243 gbump(-1); |
|
244 return _Traits::not_eof(c); |
|
245 } |
|
246 else if (c == gptr()[-1]) { |
|
247 gbump(-1); |
|
248 return c; |
|
249 } |
|
250 else if (!_M_constant) { |
|
251 gbump(-1); |
|
252 *gptr() = c; |
|
253 return c; |
|
254 } |
|
255 } |
|
256 |
|
257 return _Traits::eof(); |
|
258 } |
|
259 |
|
260 _STLP_EXP_DECLSPEC strstreambuf::int_type strstreambuf::underflow() |
|
261 { |
|
262 if (gptr() == egptr() && pptr() && pptr() > egptr()) |
|
263 setg(eback(), gptr(), pptr()); |
|
264 |
|
265 if (gptr() != egptr()) |
|
266 return (unsigned char) *gptr(); |
|
267 else |
|
268 return _Traits::eof(); |
|
269 } |
|
270 |
|
271 _STLP_EXP_DECLSPEC basic_streambuf<char, char_traits<char> >* |
|
272 strstreambuf::setbuf(char*, streamsize) |
|
273 { |
|
274 return this; |
|
275 } |
|
276 |
|
277 _STLP_EXP_DECLSPEC strstreambuf::pos_type |
|
278 strstreambuf::seekoff(off_type off, |
|
279 ios_base::seekdir dir, ios_base::openmode mode) |
|
280 { |
|
281 bool do_get = false; |
|
282 bool do_put = false; |
|
283 |
|
284 if ((mode & (ios_base::in | ios_base::out)) == |
|
285 (ios_base::in | ios_base::out) && |
|
286 (dir == ios_base::beg || dir == ios_base::end)) |
|
287 do_get = do_put = true; |
|
288 else if (mode & ios_base::in) |
|
289 do_get = true; |
|
290 else if (mode & ios_base::out) |
|
291 do_put = true; |
|
292 |
|
293 // !gptr() is here because, according to D.7.1 paragraph 4, the seekable |
|
294 // area is undefined if there is no get area. |
|
295 if ((!do_get && !do_put) || (do_put && !pptr()) || !gptr()) |
|
296 return pos_type(off_type(-1)); |
|
297 |
|
298 char* seeklow = eback(); |
|
299 char* seekhigh = epptr() ? epptr() : egptr(); |
|
300 |
|
301 off_type newoff; |
|
302 switch(dir) { |
|
303 case ios_base::beg: |
|
304 newoff = 0; |
|
305 break; |
|
306 case ios_base::end: |
|
307 newoff = seekhigh - seeklow; |
|
308 break; |
|
309 case ios_base::cur: |
|
310 newoff = do_put ? pptr() - seeklow : gptr() - seeklow; |
|
311 break; |
|
312 default: |
|
313 return pos_type(off_type(-1)); |
|
314 } |
|
315 |
|
316 off += newoff; |
|
317 if (off < 0 || off > seekhigh - seeklow) |
|
318 return pos_type(off_type(-1)); |
|
319 |
|
320 if (do_put) { |
|
321 if (seeklow + off < pbase()) { |
|
322 setp(seeklow, epptr()); |
|
323 pbump((int)off); |
|
324 } |
|
325 else { |
|
326 setp(pbase(), epptr()); |
|
327 pbump((int)(off - (pbase() - seeklow))); |
|
328 } |
|
329 } |
|
330 if (do_get) { |
|
331 if (off <= egptr() - seeklow) |
|
332 setg(seeklow, seeklow + off, egptr()); |
|
333 else if (off <= pptr() - seeklow) |
|
334 setg(seeklow, seeklow + off, pptr()); |
|
335 else |
|
336 setg(seeklow, seeklow + off, epptr()); |
|
337 } |
|
338 #ifndef __SYMBIAN32__ |
|
339 return pos_type(newoff); |
|
340 #else |
|
341 return pos_type(off); |
|
342 #endif |
|
343 } |
|
344 |
|
345 _STLP_EXP_DECLSPEC strstreambuf::pos_type |
|
346 strstreambuf::seekpos(pos_type pos, ios_base::openmode mode) |
|
347 { |
|
348 return seekoff(pos - pos_type(off_type(0)), ios_base::beg, mode); |
|
349 } |
|
350 |
|
351 |
|
352 char* strstreambuf::_M_alloc(size_t n) |
|
353 { |
|
354 if (_M_alloc_fun) |
|
355 return __STATIC_CAST(char*,_M_alloc_fun(n)); |
|
356 else |
|
357 return new char[n]; |
|
358 } |
|
359 |
|
360 void strstreambuf::_M_setup(char* get, char* put, streamsize n) |
|
361 { |
|
362 if (get) { |
|
363 size_t N = n > 0 ? size_t(n) : n == 0 ? strlen(get) : size_t(INT_MAX); |
|
364 |
|
365 if (put) { |
|
366 if(put == get) |
|
367 setg(get, get, put + N); |
|
368 else |
|
369 #ifndef __SYMBIAN32__ |
|
370 setg(get, get, put); |
|
371 setp(put, put + N); |
|
372 #else |
|
373 setg(get, get, put + N-(put-get)); |
|
374 setp(put, put + N-(put-get)); |
|
375 #endif |
|
376 } |
|
377 else { |
|
378 setg(get, get, get + N); |
|
379 } |
|
380 } |
|
381 } |
|
382 |
|
383 //---------------------------------------------------------------------- |
|
384 // Class istrstream |
|
385 |
|
386 _STLP_EXP_DECLSPEC istrstream::istrstream(char* s) |
|
387 : basic_istream<char, char_traits<char> >(0), _M_buf(s, 0) |
|
388 { |
|
389 this->init(&_M_buf); |
|
390 } |
|
391 |
|
392 _STLP_EXP_DECLSPEC istrstream::istrstream(const char* s) |
|
393 : basic_istream<char, char_traits<char> >(0), _M_buf(s, 0) |
|
394 { |
|
395 this->init(&_M_buf); |
|
396 } |
|
397 |
|
398 _STLP_EXP_DECLSPEC istrstream::istrstream(char* s, streamsize n) |
|
399 : basic_istream<char, char_traits<char> >(0), _M_buf(s, n) |
|
400 { |
|
401 this->init(&_M_buf); |
|
402 } |
|
403 |
|
404 _STLP_EXP_DECLSPEC istrstream::istrstream(const char* s, streamsize n) |
|
405 : basic_istream<char, char_traits<char> >(0), _M_buf(s, n) |
|
406 { |
|
407 this->init(&_M_buf); |
|
408 } |
|
409 |
|
410 _STLP_EXP_DECLSPEC istrstream::~istrstream() {} |
|
411 |
|
412 _STLP_EXP_DECLSPEC strstreambuf* istrstream::rdbuf() const { |
|
413 return __CONST_CAST(strstreambuf*,&_M_buf); |
|
414 } |
|
415 |
|
416 _STLP_EXP_DECLSPEC char* istrstream::str() { return _M_buf.str(); } |
|
417 |
|
418 //---------------------------------------------------------------------- |
|
419 // Class ostrstream |
|
420 |
|
421 _STLP_EXP_DECLSPEC ostrstream::ostrstream() |
|
422 : basic_ostream<char, char_traits<char> >(0), _M_buf() |
|
423 { |
|
424 basic_ios<char, char_traits<char> >::init(&_M_buf); |
|
425 } |
|
426 |
|
427 _STLP_EXP_DECLSPEC ostrstream::ostrstream(char* s, int n, ios_base::openmode mode) |
|
428 : basic_ostream<char, char_traits<char> >(0), |
|
429 _M_buf(s, n, mode & ios_base::app ? s + strlen(s) : s) |
|
430 { |
|
431 basic_ios<char, char_traits<char> >::init(&_M_buf); |
|
432 } |
|
433 |
|
434 _STLP_EXP_DECLSPEC ostrstream::~ostrstream() {} |
|
435 |
|
436 _STLP_EXP_DECLSPEC strstreambuf* ostrstream::rdbuf() const |
|
437 { |
|
438 return __CONST_CAST(strstreambuf*,&_M_buf); |
|
439 } |
|
440 |
|
441 _STLP_EXP_DECLSPEC void ostrstream::freeze(bool freezeflag) |
|
442 { |
|
443 _M_buf.freeze(freezeflag); |
|
444 } |
|
445 |
|
446 _STLP_EXP_DECLSPEC char* ostrstream::str() |
|
447 { |
|
448 return _M_buf.str(); |
|
449 } |
|
450 |
|
451 _STLP_EXP_DECLSPEC int ostrstream::pcount() const |
|
452 { |
|
453 return _M_buf.pcount(); |
|
454 } |
|
455 |
|
456 |
|
457 //---------------------------------------------------------------------- |
|
458 // Class strstream |
|
459 |
|
460 _STLP_EXP_DECLSPEC strstream::strstream() |
|
461 : basic_iostream<char, char_traits<char> >(0), _M_buf() |
|
462 { |
|
463 basic_ios<char, char_traits<char> >::init(&_M_buf); |
|
464 } |
|
465 |
|
466 _STLP_EXP_DECLSPEC strstream::strstream(char* s, int n, ios_base::openmode mode) |
|
467 : basic_iostream<char, char_traits<char> >(0), |
|
468 _M_buf(s, n, mode & ios_base::app ? s + strlen(s) : s) |
|
469 { |
|
470 basic_ios<char, char_traits<char> >::init(&_M_buf); |
|
471 } |
|
472 |
|
473 _STLP_EXP_DECLSPEC strstream::~strstream() {} |
|
474 |
|
475 _STLP_EXP_DECLSPEC strstreambuf* strstream::rdbuf() const |
|
476 { |
|
477 return __CONST_CAST(strstreambuf*,&_M_buf); |
|
478 } |
|
479 |
|
480 _STLP_EXP_DECLSPEC void strstream::freeze(bool freezeflag) |
|
481 { |
|
482 _M_buf.freeze(freezeflag); |
|
483 } |
|
484 |
|
485 _STLP_EXP_DECLSPEC int strstream::pcount() const |
|
486 { |
|
487 return _M_buf.pcount(); |
|
488 } |
|
489 |
|
490 _STLP_EXP_DECLSPEC char* strstream::str() |
|
491 { |
|
492 return _M_buf.str(); |
|
493 } |
|
494 |
|
495 _STLP_END_NAMESPACE |
|
496 |
|
497 // Local Variables: |
|
498 // mode:C++ |
|
499 // End: |