strstream.cpp | Explore in Territory

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include <__assert>
#include <__utility/unreachable.h>
#include <algorithm>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <strstream>

_LIBCPP_PUSH_MACROS
#include <__undef_macros>

_LIBCPP_BEGIN_NAMESPACE_STD

strstreambuf::strstreambuf(streamsize __alsize)
    : __strmode_(__dynamic), __alsize_(__alsize), __palloc_(nullptr), __pfree_(nullptr) {}

strstreambuf::strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*))
    : __strmode_(__dynamic), __alsize_(__default_alsize), __palloc_(__palloc), __pfree_(__pfree) {}

void strstreambuf::__init(char* __gnext, streamsize __n, char* __pbeg) {
  if (__n == 0)
    __n = static_cast<streamsize>(strlen(__gnext));
  else if (__n < 0)
    __n = INT_MAX;
  if (__pbeg == nullptr)
    setg(__gnext, __gnext, __gnext + __n);
  else {
    setg(__gnext, __gnext, __pbeg);
    setp(__pbeg, __pbeg + __n);
  }
}

strstreambuf::strstreambuf(char* __gnext, streamsize __n, char* __pbeg)
    : __strmode_(), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
  __init(__gnext, __n, __pbeg);
}

strstreambuf::strstreambuf(const char* __gnext, streamsize __n)
    : __strmode_(__constant), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
  __init(const_cast<char*>(__gnext), __n, nullptr);
}

strstreambuf::strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg)
    : __strmode_(), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg));
}

strstreambuf::strstreambuf(const signed char* __gnext, streamsize __n)
    : __strmode_(__constant), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, nullptr);
}

strstreambuf::strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg)
    : __strmode_(), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg));
}

strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
    : __strmode_(__constant), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, nullptr);
}

strstreambuf::~strstreambuf() {
  if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {
    if (__pfree_)
      __pfree_(eback());
    else
      delete[] eback();
  }
}

void strstreambuf::swap(strstreambuf& __rhs) {
  streambuf::swap(__rhs);
  std::swap(__strmode_, __rhs.__strmode_);
  std::swap(__alsize_, __rhs.__alsize_);
  std::swap(__palloc_, __rhs.__palloc_);
  std::swap(__pfree_, __rhs.__pfree_);
}

void strstreambuf::freeze(bool __freezefl) {
  if (__strmode_ & __dynamic) {
    if (__freezefl)
      __strmode_ |= __frozen;
    else
      __strmode_ &= ~__frozen;
  }
}

char* strstreambuf::str() {
  if (__strmode_ & __dynamic)
    __strmode_ |= __frozen;
  return eback();
}

int strstreambuf::pcount() const { return static_cast<int>(pptr() - pbase()); }

strstreambuf::int_type strstreambuf::overflow(int_type __c) {
  if (__c == EOF)
    return int_type(0);
  if (pptr() == epptr()) {
    if ((__strmode_ & __dynamic) == 0 || (__strmode_ & __frozen) != 0)
      return int_type(EOF);
    size_t old_size = static_cast<size_t>((epptr() ? epptr() : egptr()) - eback());
    size_t new_size = max<size_t>(static_cast<size_t>(__alsize_), 2 * old_size);
    if (new_size == 0)
      new_size = __default_alsize;
    char* buf = nullptr;
    if (__palloc_)
      buf = static_cast<char*>(__palloc_(new_size));
    else
      buf = new char[new_size];
    if (buf == nullptr)
      return int_type(EOF);
    if (old_size != 0) {
      _LIBCPP_ASSERT_INTERNAL(eback(), "strstreambuf::overflow reallocating but the get area is a null pointer");
      memcpy(buf, eback(), static_cast<size_t>(old_size));
    }
    ptrdiff_t ninp = gptr() - eback();
    ptrdiff_t einp = egptr() - eback();
    ptrdiff_t nout = pptr() - pbase();
    if (__strmode_ & __allocated) {
      if (__pfree_)
        __pfree_(eback());
      else
        delete[] eback();
    }
    setg(buf, buf + ninp, buf + einp);
    setp(buf + einp, buf + new_size);
    __pbump(nout);
    __strmode_ |= __allocated;
  }
  *pptr() = static_cast<char>(__c);
  pbump(1);
  return int_type(static_cast<unsigned char>(__c));
}

strstreambuf::int_type strstreambuf::pbackfail(int_type __c) {
  if (eback() == gptr())
    return EOF;
  if (__c == EOF) {
    gbump(-1);
    return int_type(0);
  }
  if (__strmode_ & __constant) {
    if (gptr()[-1] == static_cast<char>(__c)) {
      gbump(-1);
      return __c;
    }
    return EOF;
  }
  gbump(-1);
  *gptr() = static_cast<char>(__c);
  return __c;
}

strstreambuf::int_type strstreambuf::underflow() {
  if (gptr() == egptr()) {
    if (egptr() >= pptr())
      return EOF;
    setg(eback(), gptr(), pptr());
  }
  return int_type(static_cast<unsigned char>(*gptr()));
}

strstreambuf::pos_type strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which) {
  bool pos_in  = (__which & ios::in) != 0;
  bool pos_out = (__which & ios::out) != 0;
  switch (__way) {
  case ios::beg:
  case ios::end:
    if (!pos_in && !pos_out)
      return pos_type(off_type(-1));
    break;
  case ios::cur:
    if (pos_in == pos_out)
      return pos_type(off_type(-1));
    break;
  }

  if (pos_in && gptr() == nullptr)
    return pos_type(off_type(-1));
  if (pos_out && pptr() == nullptr)
    return pos_type(off_type(-1));

  off_type newoff;
  char* seekhigh = epptr() ? epptr() : egptr();
  switch (__way) {
  case ios::beg:
    newoff = 0;
    break;
  case ios::cur:
    newoff = (pos_in ? gptr() : pptr()) - eback();
    break;
  case ios::end:
    newoff = seekhigh - eback();
    break;
  default:
    __libcpp_unreachable();
  }
  newoff += __off;
  if (newoff < 0 || newoff > seekhigh - eback())
    return pos_type(off_type(-1));

  char* newpos = eback() + newoff;
  if (pos_in)
    setg(eback(), newpos, std::max(newpos, egptr()));
  if (pos_out) {
    // min(pbase, newpos), newpos, epptr()
    __off = epptr() - newpos;
    setp(min(pbase(), newpos), epptr());
    __pbump((epptr() - pbase()) - __off);
  }
  return pos_type(newoff);
}

strstreambuf::pos_type strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which) {
  bool pos_in  = (__which & ios::in) != 0;
  bool pos_out = (__which & ios::out) != 0;
  if (!pos_in && !pos_out)
    return pos_type(off_type(-1));

  if ((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr))
    return pos_type(off_type(-1));

  off_type newoff = __sp;
  char* seekhigh  = epptr() ? epptr() : egptr();
  if (newoff < 0 || newoff > seekhigh - eback())
    return pos_type(off_type(-1));

  char* newpos = eback() + newoff;
  if (pos_in)
    setg(eback(), newpos, std::max(newpos, egptr()));
  if (pos_out) {
    // min(pbase, newpos), newpos, epptr()
    off_type temp = epptr() - newpos;
    setp(min(pbase(), newpos), epptr());
    __pbump((epptr() - pbase()) - temp);
  }
  return pos_type(newoff);
}

istrstream::~istrstream() {}

ostrstream::~ostrstream() {}

strstream::~strstream() {}

_LIBCPP_END_NAMESPACE_STD

_LIBCPP_POP_MACROS
llvm/libcxx/src/strstream.cpp
