00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
#include <strstream>
00050
#include <algorithm>
00051
#include <new>
00052
#include <stdlib.h>
00053
#include <string.h>
00054
#include <limits.h>
00055
00056
namespace std
00057 {
00058 strstreambuf::strstreambuf(streamsize initial_capacity)
00059 : _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(true),
00060 _M_frozen(false), _M_constant(false)
00061 {
00062 streamsize n =
max(initial_capacity, streamsize(16));
00063
00064
char* buf = _M_alloc(n);
00065
if (buf)
00066 {
00067
setp(buf, buf + n);
00068
setg(buf, buf, buf);
00069 }
00070 }
00071
00072 strstreambuf::strstreambuf(
void* (*alloc_f)(size_t),
void (*free_f)(
void*))
00073 : _Base(), _M_alloc_fun(alloc_f), _M_free_fun(free_f), _M_dynamic(true),
00074 _M_frozen(false), _M_constant(false)
00075 {
00076 streamsize n = 16;
00077
00078
char* buf = _M_alloc(n);
00079
if (buf)
00080 {
00081
setp(buf, buf + n);
00082
setg(buf, buf, buf);
00083 }
00084 }
00085
00086 strstreambuf::strstreambuf(
char* get, streamsize n,
char* put)
00087 : _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(false),
00088 _M_frozen(false), _M_constant(false)
00089 { _M_setup(get, put, n); }
00090
00091 strstreambuf::strstreambuf(
signed char* get, streamsize n,
signed char* put)
00092 : _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(false),
00093 _M_frozen(false), _M_constant(false)
00094 { _M_setup(reinterpret_cast<char*>(get), reinterpret_cast<char*>(put), n); }
00095
00096 strstreambuf::strstreambuf(
unsigned char* get, streamsize n,
00097
unsigned char* put)
00098 : _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(false),
00099 _M_frozen(false), _M_constant(false)
00100 { _M_setup(reinterpret_cast<char*>(get), reinterpret_cast<char*>(put), n); }
00101
00102 strstreambuf::strstreambuf(
const char* get, streamsize n)
00103 : _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(false),
00104 _M_frozen(false), _M_constant(true)
00105 { _M_setup(const_cast<char*>(get), 0, n); }
00106
00107 strstreambuf::strstreambuf(
const signed char* get, streamsize n)
00108 : _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(false),
00109 _M_frozen(false), _M_constant(true)
00110 { _M_setup(reinterpret_cast<char*>(const_cast<signed char*>(get)), 0, n); }
00111
00112 strstreambuf::strstreambuf(
const unsigned char* get, streamsize n)
00113 : _Base(), _M_alloc_fun(0), _M_free_fun(0), _M_dynamic(false),
00114 _M_frozen(false), _M_constant(true)
00115 { _M_setup(reinterpret_cast<char*>(const_cast<unsigned char*>(get)), 0, n); }
00116
00117 strstreambuf::~strstreambuf()
00118 {
00119
if (_M_dynamic && !_M_frozen)
00120 _M_free(
eback());
00121 }
00122
00123
void
00124 strstreambuf::freeze(
bool frozenflag)
00125 {
00126
if (_M_dynamic)
00127 _M_frozen = frozenflag;
00128 }
00129
00130
char*
00131 strstreambuf::str()
00132 {
00133 freeze(
true);
00134
return eback();
00135 }
00136
00137
int
00138 strstreambuf::pcount()
const
00139
{
return pptr() ?
pptr() -
pbase() : 0; }
00140
00141 strstreambuf::int_type
00142 strstreambuf::overflow(int_type c)
00143 {
00144
if (c == traits_type::eof())
00145
return traits_type::not_eof(c);
00146
00147
00148
if (
pptr() ==
epptr() && _M_dynamic && !_M_frozen && !_M_constant)
00149 {
00150 ptrdiff_t old_size =
epptr() -
pbase();
00151 ptrdiff_t new_size =
max(ptrdiff_t(2 * old_size), ptrdiff_t(1));
00152
00153
char* buf = _M_alloc(new_size);
00154
if (buf)
00155 {
00156 memcpy(buf,
pbase(), old_size);
00157
char* old_buffer =
pbase();
00158
bool reposition_get =
false;
00159 ptrdiff_t old_get_offset;
00160
if (
gptr() != 0)
00161 {
00162 reposition_get =
true;
00163 old_get_offset =
gptr() -
eback();
00164 }
00165
00166
setp(buf, buf + new_size);
00167
pbump(old_size);
00168
00169
if (reposition_get)
00170
setg(buf, buf + old_get_offset, buf +
00171
max(old_get_offset, old_size));
00172
00173 _M_free(old_buffer);
00174 }
00175 }
00176
00177
if (
pptr() !=
epptr())
00178 {
00179 *
pptr() = c;
00180
pbump(1);
00181
return c;
00182 }
00183
else
00184
return traits_type::eof();
00185 }
00186
00187 strstreambuf::int_type
00188 strstreambuf::pbackfail(int_type c)
00189 {
00190
if (
gptr() !=
eback())
00191 {
00192
if (c == _Traits::eof())
00193 {
00194
gbump(-1);
00195
return _Traits::not_eof(c);
00196 }
00197
else if (c == static_cast<int_type>(
gptr()[-1]))
00198 {
00199
gbump(-1);
00200
return c;
00201 }
00202
else if (!_M_constant)
00203 {
00204
gbump(-1);
00205 *
gptr() = c;
00206
return c;
00207 }
00208 }
00209
return _Traits::eof();
00210 }
00211
00212 strstreambuf::int_type
00213 strstreambuf::underflow()
00214 {
00215
if (
gptr() ==
egptr() &&
pptr() &&
pptr() >
egptr())
00216
setg(
eback(),
gptr(),
pptr());
00217
00218
if (
gptr() !=
egptr())
00219
return (
unsigned char) *
gptr();
00220
else
00221
return _Traits::eof();
00222 }
00223
00224 basic_streambuf<char, char_traits<char> >*
00225 strstreambuf::setbuf(
char*, streamsize)
00226 {
return this; }
00227
00228 strstreambuf::pos_type
00229 strstreambuf::seekoff(off_type off, ios_base::seekdir dir,
00230 ios_base::openmode mode)
00231 {
00232
bool do_get =
false;
00233
bool do_put =
false;
00234
00235
if ((mode & (ios_base::in | ios_base::out))
00236 == (ios_base::in | ios_base::out) &&
00237 (dir == ios_base::beg || dir == ios_base::end))
00238 do_get = do_put =
true;
00239
else if (mode & ios_base::in)
00240 do_get =
true;
00241
else if (mode & ios_base::out)
00242 do_put =
true;
00243
00244
00245
00246
if ((!do_get && !do_put) || (do_put && !
pptr()) || !
gptr())
00247
return pos_type(
off_type(-1));
00248
00249
char* seeklow =
eback();
00250
char* seekhigh =
epptr() ?
epptr() :
egptr();
00251
00252
off_type newoff;
00253
switch (dir)
00254 {
00255
case ios_base::beg:
00256 newoff = 0;
00257
break;
00258
case ios_base::end:
00259 newoff = seekhigh - seeklow;
00260
break;
00261
case ios_base::cur:
00262 newoff = do_put ?
pptr() - seeklow :
gptr() - seeklow;
00263
break;
00264
default:
00265
return pos_type(
off_type(-1));
00266 }
00267
00268 off += newoff;
00269
if (off < 0 || off > seekhigh - seeklow)
00270
return pos_type(
off_type(-1));
00271
00272
if (do_put)
00273 {
00274
if (seeklow + off <
pbase())
00275 {
00276
setp(seeklow,
epptr());
00277
pbump(off);
00278 }
00279
else
00280 {
00281
setp(
pbase(),
epptr());
00282
pbump(off - (
pbase() - seeklow));
00283 }
00284 }
00285
if (do_get)
00286 {
00287
if (off <=
egptr() - seeklow)
00288
setg(seeklow, seeklow + off,
egptr());
00289
else if (off <=
pptr() - seeklow)
00290
setg(seeklow, seeklow + off,
pptr());
00291
else
00292
setg(seeklow, seeklow + off,
epptr());
00293 }
00294
return pos_type(newoff);
00295 }
00296
00297 strstreambuf::pos_type
00298 strstreambuf::seekpos(pos_type pos, ios_base::openmode mode)
00299 {
return seekoff(pos -
pos_type(
off_type(0)), ios_base::beg, mode); }
00300
00301
char*
00302 strstreambuf::_M_alloc(size_t n)
00303 {
00304
if (_M_alloc_fun)
00305
return static_cast<char*>(_M_alloc_fun(n));
00306
else
00307
return new char[n];
00308 }
00309
00310
void
00311 strstreambuf::_M_free(
char* p)
00312 {
00313
if (p)
00314
if (_M_free_fun)
00315 _M_free_fun(p);
00316
else
00317
delete[] p;
00318 }
00319
00320
void
00321 strstreambuf::_M_setup(
char* get,
char* put, streamsize n)
00322 {
00323
if (get)
00324 {
00325 size_t N = n > 0 ? size_t(n) : n == 0 ? strlen(get) : size_t(INT_MAX);
00326
00327
if (put)
00328 {
00329
setg(get, get, put);
00330
setp(put, put + N);
00331 }
00332
else
00333
setg(get, get, get + N);
00334 }
00335 }
00336
00337 istrstream::istrstream(
char* s)
00338 : basic_ios<char>(), basic_istream<char>(0), _M_buf(s, 0)
00339 { basic_ios<char>::init(&_M_buf); }
00340
00341 istrstream::istrstream(
const char* s)
00342 : basic_ios<char>(), basic_istream<char>(0), _M_buf(s, 0)
00343 { basic_ios<char>::init(&_M_buf); }
00344
00345 istrstream::istrstream(
char* s, streamsize n)
00346 : basic_ios<char>(), basic_istream<char>(0), _M_buf(s, n)
00347 { basic_ios<char>::init(&_M_buf); }
00348
00349 istrstream::istrstream(
const char* s, streamsize n)
00350 : basic_ios<char>(), basic_istream<char>(0), _M_buf(s, n)
00351 { basic_ios<char>::init(&_M_buf); }
00352
00353 istrstream::~istrstream() { }
00354
00355 strstreambuf*
00356 istrstream::rdbuf()
const
00357
{
return const_cast<strstreambuf*>(&_M_buf); }
00358
00359
char*
00360 istrstream::str()
00361 {
return _M_buf.str(); }
00362
00363 ostrstream::ostrstream()
00364 : basic_ios<char>(), basic_ostream<char>(0), _M_buf()
00365 { basic_ios<char>::init(&_M_buf); }
00366
00367 ostrstream::ostrstream(
char* s,
int n, ios_base::openmode mode)
00368 : basic_ios<char>(), basic_ostream<char>(0),
00369 _M_buf(s, n, mode & ios_base::app ? s + strlen(s) : s)
00370 { basic_ios<char>::init(&_M_buf); }
00371
00372 ostrstream::~ostrstream() {}
00373
00374 strstreambuf*
00375 ostrstream::rdbuf()
const
00376
{
return const_cast<strstreambuf*>(&_M_buf); }
00377
00378
void
00379 ostrstream::freeze(
bool freezeflag)
00380 { _M_buf.freeze(freezeflag); }
00381
00382
char*
00383 ostrstream::str()
00384 {
return _M_buf.str(); }
00385
00386
int
00387 ostrstream::pcount()
const
00388
{
return _M_buf.pcount(); }
00389
00390 strstream::strstream()
00391 : basic_ios<char>(), basic_iostream<char>(0), _M_buf()
00392 { basic_ios<char>::init(&_M_buf); }
00393
00394 strstream::strstream(
char* s,
int n, ios_base::openmode mode)
00395 : basic_ios<char>(), basic_iostream<char>(0),
00396 _M_buf(s, n, mode & ios_base::app ? s + strlen(s) : s)
00397 { basic_ios<char>::init(&_M_buf); }
00398
00399 strstream::~strstream() { }
00400
00401 strstreambuf*
00402 strstream::rdbuf()
const
00403
{
return const_cast<strstreambuf*>(&_M_buf); }
00404
00405
void
00406 strstream::freeze(
bool freezeflag)
00407 { _M_buf.freeze(freezeflag); }
00408
00409
int
00410 strstream::pcount()
const
00411
{
return _M_buf.pcount(); }
00412
00413
char*
00414 strstream::str()
00415 {
return _M_buf.str(); }
00416 }