contrib/libc++/src/strstream.cpp

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