int_type underflow()
{
if ( gptr() < egptr() )
return static_cast<int_type>(*uptr());
assert ( gptr() == egptr() );
char * midptr = buffer.begin() + pushbackspace;
uint64_t const copyavail =
std::min(
// previously read
static_cast<uint64_t>(gptr()-eback()),
// space we have to copy into
static_cast<uint64_t>(midptr-buffer.begin())
);
::std::memmove(midptr-copyavail,gptr()-copyavail,copyavail);
size_t n = 0;
bool done = false;
while ( ! done )
{
BgzfInflateInfo const info = stream.readAndInfo(midptr, buffer.end()-midptr);
n = info.uncompressed;
// non eof block
if ( n )
{
streamreadpos += n;
done = true;
}
else
{
// eof block at end of stream
if ( info.streameof )
{
done = true;
}
// intermediate empty block, skip it
else
{
}
}
}
setg(midptr-copyavail, midptr, midptr+n);
if (!n)
return traits_type::eof();
return static_cast<int_type>(*uptr());
}
int general_parsebuf::seek_in_line(int i)
{
if (__line_number == 0)
(void)general_parsebuf::underflow();
if (__line_number > 1)
i++; // Add 1 for '\n' from end of previous line.
if (i < 0) i = 0;
int len = egptr() - eback();
if (i > len) i = len;
setg(base(), base() + i, egptr());
return i;
}
strstreambuf::pos_type
strstreambuf::seekpos(pos_type pos, ios_base::openmode which)
{
if ((which & (ios_base::in | ios_base::out)) == 0
|| pos < 0 || (epptr() == 0? egptr(): epptr()) - gptr() < pos)
return pos_type(-1);
if (which & ios_base::in)
if (gptr() == 0)
return pos_type(-1);
else
setg(eback(), eback() + pos, egptr());
if (which & ios_base::in)
if (pptr() == 0)
return pos_type(-1);
else
setp(eback() + pos, epptr());
return pos;
}
/**
* seek to absolute position
**/
::std::streampos seekpos(::std::streampos sp, ::std::ios_base::openmode which = ::std::ios_base::in | ::std::ios_base::out)
{
if ( which & ::std::ios_base::in )
{
// current position
int64_t const cur = symsread-(egptr()-gptr());
// current start of buffer (relative)
int64_t const curlow = cur - static_cast<int64_t>(gptr()-eback());
// current end of buffer (relative)
int64_t const curhigh = cur + static_cast<int64_t>(egptr()-gptr());
// call relative seek, if target is in range
if ( sp >= curlow && sp <= curhigh )
return seekoff(static_cast<int64_t>(sp) - cur, ::std::ios_base::cur, which);
// target is out of range, we really need to seek
uint64_t tsymsread = (sp / blocksize)*blocksize;
// set symsread
symsread = tsymsread;
// reinit
init(true);
// read next block
underflow();
// skip bytes in block to get to final position
setg(
eback(),
gptr() + (static_cast<int64_t>(sp)-static_cast<int64_t>(tsymsread)),
egptr()
);
return sp;
}
return -1;
}
_CRTIMP2 int strstreambuf::pbackfail(int ch)
{ // try to putback a character
if (gptr() == 0 || gptr() <= eback()
|| ch != EOF
&& (unsigned char)ch != (unsigned char)gptr()[-1]
&& _Strmode & _Constant)
return (EOF);
else
{ // safe to back up
gbump(-1);
return (ch == EOF ? 0 : (unsigned char)(*gptr() = (char)ch));
}
}
strstreambuf::int_type
strstreambuf::underflow()
{
if (gptr() != egptr())
return static_cast<unsigned char>(*gptr());
else if (pptr() != 0 && egptr() != pptr())
{
setg(eback(), gptr(), pptr());
return static_cast<unsigned char>(*gptr());
}
return char_traits<char>::eof();
}
void FtpFileStream::flushPutback() {
if (mPutbackBuffer.size() == 0) {
return;
}
auto g = gptr();
uint32 offset = g - eback();
mCurrentBuffer.insert(mCurrentBuffer.end(), mPutbackBuffer.begin(), mPutbackBuffer.end());
mPutbackBuffer.clear();
setg(&mCurrentBuffer[0], &mCurrentBuffer[offset], &mCurrentBuffer[mCurrentBuffer.size() - 1]);
}
MessageBuffer::int_type MessageBuffer::underflow()
{
if( this->gptr() < this->pptr() )
{
std::size_t gsize = gptr() - eback();
this->setg(_buffer, _buffer + gsize, this->pptr());
}
if( this->gptr() < this->egptr() )
return traits_type::to_int_type(*(this->gptr()));
return traits_type::eof();
}
// base showmanyc() returns 0 to indicate we don't know how many characters are available
virtual int_type underflow() override { // add some characters to the buffer if empty
if (gptr()<egptr()) return traits_type::to_int_type(*gptr());
// copy up to putback_size previously read characters into putback buffer
int putback_num = 0;
if (1) {
putback_num = min(int(gptr()-eback()), possible_cast<int>(putback_size));
ASSERTX(putback_num>=0 && putback_num<=putback_size);
std::memmove(_buffer0-putback_num, gptr()-putback_num, putback_num); // ranges may overlap
}
size_t num = fread(_buffer0, sizeof(char), buffer_size, _file);
if (!num) return EOF; // on failure we retain gptr()==egptr()
setg(_buffer0-putback_num, _buffer0, _buffer0+num);
return traits_type::to_int_type(*gptr());
}
std::streampos seekoff(std::streamoff off, std::ios_base::seekdir dir, std::ios_base::openmode) {
char *p;
switch (dir) {
case std::ios_base::beg:
p = eback() + off;
break;
case std::ios_base::cur:
p = gptr() + off;
break;
case std::ios_base::end:
p = egptr() - off;
break;
default:
p = 0;
break;
}
if (p >= eback() && p <= egptr()) {
setg(eback(), p, egptr());
return std::streampos(p - eback());
} else {
return -1;
}
}
exec_stream_buffer_t::int_type exec_stream_buffer_t::underflow()
{
if( gptr()==egptr() ) {
std::size_t read_size=STREAM_BUFFER_SIZE;
bool no_more;
m_thread_buffer.get( m_kind, m_stream_buffer, read_size, no_more );
if( no_more || read_size==0 ) { // there is no way for underflow to return something other than eof when 0 bytes are read
return traits_type::eof();
}else {
setg( m_stream_buffer, m_stream_buffer, m_stream_buffer+read_size );
}
}
return traits_type::to_int_type( *eback() );
}
void strstreambuf::freeze(bool freezeit)
{ // freeze or unfreeze writing
if (freezeit && !(_Strmode & _Frozen))
{ // disable writing
_Strmode |= _Frozen;
_Pendsave = epptr();
setp(pbase(), pptr(), eback());
}
else if (!freezeit && _Strmode & _Frozen)
{ // re-enable writing
_Strmode &= ~_Frozen;
setp(pbase(), pptr(), _Pendsave);
}
}
// According to the C++ standard the effects of setbuf are implementation
// defined, except that setbuf(0, 0) has no effect. In this implementation,
// setbuf(<anything>, __length), for __length > 0, calls reserve(__length) on the underlying
// string.
streambuf* stringbuf::setbuf(char_type*, streamsize __length)
{
if (__length > 0)
{
bool __do_get_area = false;
bool __do_put_area = false;
ptrdiff_t __offg = 0;
ptrdiff_t __offp = 0;
if (pbase() == __M_str.begin())
{
__do_put_area = true;
__offp = pptr() - pbase();
}
if (eback() == __M_str.begin())
{
__do_get_area = true;
__offg = gptr() - eback();
}
__M_str.reserve(static_cast<size_t>(__length));
char_type* __data_ptr = __M_str.begin();
if (__do_get_area)
{
setg(__data_ptr, __data_ptr + __offg, __M_str.end());
}
if (__do_put_area)
{
setp(__data_ptr, __M_str.end());
pbump(static_cast<int>(__offp));
}
}
return this;
}
int TCPStream::underflow()
{
ssize_t rlen = 1;
unsigned char ch;
if(bufsize == 1) {
if(Socket::state == STREAM)
rlen = ::read((int)so, (char *)&ch, 1);
else if(timeout && !Socket::isPending(pendingInput, timeout)) {
iostream::clear(ios::failbit | rdstate());
error(errTimeout,(char *)"Socket read timed out",socket_errno);
return EOF;
}
else
rlen = readData(&ch, 1);
if(rlen < 1) {
if(rlen < 0) {
iostream::clear(ios::failbit | rdstate());
error(errInput,(char *)"Could not read from socket",socket_errno);
}
return EOF;
}
return ch;
}
if(!gptr())
return EOF;
if(gptr() < egptr())
return (unsigned char)*gptr();
rlen = (ssize_t)((gbuf + bufsize) - eback());
if(Socket::state == STREAM)
rlen = ::read((int)so, (char *)eback(), _IOLEN64 rlen);
else if(timeout && !Socket::isPending(pendingInput, timeout)) {
iostream::clear(ios::failbit | rdstate());
error(errTimeout,(char *)"Socket read timed out",socket_errno);
return EOF;
}
else
rlen = readData(eback(), rlen);
if(rlen < 1) {
// clear(ios::failbit | rdstate());
if(rlen < 0)
error(errNotConnected,(char *)"Connection error",socket_errno);
else {
error(errInput,(char *)"Could not read from socket",socket_errno);
iostream::clear(ios::failbit | rdstate());
}
return EOF;
}
error(errSuccess);
setg(eback(), eback(), eback() + rlen);
return (unsigned char) *gptr();
}
//unget char, some special cases
int StringIteratorStreamBuf::pbackfail ( int c )
{
if(eback() != gptr())
{
setg(eback(), gptr()-1, egptr());
if(c != EOF)
*gptr() = (char)c;
return 1;
}
//else have to rewind to previous buffer
if(last_buffer != current_buffer)
return EOF;
if(buffer[1-last_buffer].length() == 0)
return EOF;
current_buffer = 1 - current_buffer;
begin_offset -= buffer[current_buffer].length();
char *buffstr = (char*)buffer[current_buffer].c_str();
setg(buffstr, buffstr+buffer[current_buffer].length()-1, buffstr+buffer[current_buffer].length());
if(c != EOF)
*gptr() = (char)c;
return 1;
}
::std::streampos seekoff(::std::streamoff off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which = ::std::ios_base::in | ::std::ios_base::out)
{
if ( which & ::std::ios_base::in )
{
int64_t abstarget = 0;
int64_t const cur = symsread - (egptr()-gptr());
if ( way == ::std::ios_base::cur )
abstarget = cur + off;
else if ( way == ::std::ios_base::beg )
abstarget = off;
else // if ( way == ::std::ios_base::end )
abstarget = n + (addterm?1:0) + off;
if ( abstarget - cur == 0 )
{
return abstarget;
}
else if ( (abstarget - cur) > 0 && (abstarget - cur) <= (egptr()-gptr()) )
{
setg(eback(),gptr()+(abstarget-cur),egptr());
return abstarget;
}
else if ( (abstarget - cur) < 0 && (cur-abstarget) <= (gptr()-eback()) )
{
setg(eback(),gptr()-(cur-abstarget),egptr());
return abstarget;
}
else
{
return seekpos(abstarget,which);
}
}
return -1;
}
_STLP_EXP_DECLSPEC strstreambuf::int_type strstreambuf::overflow(int_type c) {
if (c == traits_type::eof())
return traits_type::not_eof(c);
#ifdef __SYMBIAN32__
if (pptr() != 0 && pptr() < epptr())
{
*pptr() = c;
pbump(1);
return c;
}
if (!_M_dynamic || _M_constant || _M_frozen)
return (EOF); // can't extend
#endif
// Try to expand the buffer.
if (pptr() == epptr() && _M_dynamic && !_M_frozen && !_M_constant) {
ptrdiff_t old_size = epptr() - pbase();
ptrdiff_t new_size = (max)(2 * old_size, ptrdiff_t(1));
char* buf = _M_alloc(new_size);
if (buf) {
memcpy(buf, pbase(), old_size);
char* old_buffer = pbase();
bool reposition_get = false;
ptrdiff_t old_get_offset;
if (gptr() != 0) {
reposition_get = true;
old_get_offset = gptr() - eback();
}
setp(buf, buf + new_size);
pbump((int)old_size);
if (reposition_get)
setg(buf, buf + old_get_offset, buf + (max)(old_get_offset, old_size));
_M_free(old_buffer);
}
}
if (pptr() != epptr()) {
*pptr() = c;
pbump(1);
return c;
}
else
return traits_type::eof();
}
mlpipebuf::int_type
mlpipebuf::pbackfail(int_type c)
{
#ifdef DEBUG
char *fname = "mlpipebuf::pbackfail(c)";
Tracebuf T(fname);
#endif
if(gptr() != eback()) {
gbump(-1);
if(c != ((int)EOF))
*(gptr()) = char(c);
return c;
} else
return (int(EOF));
}
std::streambuf::pos_type
DataIStreamBuf::seekpos(pos_type sp, std::ios_base::openmode which)
{
pos_type ret = pos_type(off_type(-1));
char* begin = eback();
char* end = egptr();
if (sp <= end - begin)
{
setg(begin, begin + sp, end);
ret = sp;
}
return ret;
}
int strstreambuf::doallocate()
{
char * bptr;
int size;
size = __max(x_bufmin,blen() + __max(x_bufmin,1));
long offset = 0;
if (x_alloc)
{
bptr = (char*)(*x_alloc)(size);
}
else
{
bptr = _new_crt char[size];
}
if (!bptr)
return EOF;
if (blen())
{
memcpy(bptr, base(), blen());
offset = bptr - base(); // amount to adjust pointers by
}
if (x_free)
{
(*x_free)(base());
}
else
{
delete base();
}
setb(bptr,bptr+size,0); // we handle deallocation
// adjust get/put pointers too, if necessary
if (offset)
if (egptr())
{
setg(eback()+offset,gptr()+offset,egptr()+offset);
}
if (epptr())
{
size = pptr() - pbase();
setp(pbase()+offset,epptr()+offset);
pbump(size);
}
return(1);
}
_CRTIMP2 int strstreambuf::overflow(int ch)
{ // try to extend write area
if (ch == EOF)
return (0);
else if (pptr() != 0 && pptr() < epptr())
return ((unsigned char)(*_Pninc() = (char)ch));
else if (!(_Strmode & _Dynamic)
|| _Strmode & (_Constant | _Frozen))
return (EOF);
else
{ // okay to extend
int osize = gptr() == 0 ? 0 : epptr() - eback();
int nsize = osize + _Alsize;
char *p = _Palloc != 0 ? (char *)(*_Palloc)(nsize)
: new char[nsize];
if (p == 0)
return (EOF);
if (0 < osize)
memcpy(p, eback(), osize);
else if (_ALSIZE < _Alsize)
_Alsize = _ALSIZE;
if (!(_Strmode & _Allocated))
;
else if (_Pfree != 0)
(*_Pfree)(eback());
else
delete[] eback();
_Strmode |= _Allocated;
if (osize == 0)
{ // setup new buffer
_Seekhigh = p;
setp(p, p + nsize);
setg(p, p, p);
}
else
{ // revise old pointers
_Seekhigh = _Seekhigh - eback() + p;
setp(pbase() - eback() + p, pptr() - eback() + p,
p + nsize);
setg(p, gptr() - eback() + p, pptr() + 1);
}
return ((unsigned char)(*_Pninc() = (char)ch));
}
}
_CRTIMP2 int strstreambuf::underflow()
{ // read only if read position available
if (gptr() == 0)
return (EOF);
else if (gptr() < egptr())
return ((unsigned char)*gptr());
else if (pptr() == 0
|| pptr() <= gptr() && _Seekhigh <= gptr())
return (EOF);
else
{ // update _Seekhigh and expand read region
if (_Seekhigh < pptr())
_Seekhigh = pptr();
setg(eback(), gptr(), _Seekhigh);
return ((unsigned char)*gptr());
}
}
/**
Put bit at get pointer.
\param[out] b Bit to be put back.
\return Whether okay (eof has not been encountered).
*/
bool sputbackb(bitfield b)
{
bool putback_succeeded;
if (gptr() == std::streampos(-1) || gptr() == eback() ||
b != atgptrb(-1))
{
putback_succeeded = pbackfail(b);
}
else
{
gbump(-1);
putback_succeeded = gptr() != std::streampos(-1);
}
return putback_succeeded;
}
/**
Move get pointer backwards and return bit at new position.
\param[out] value Bit before position prior to call.
\return Whether okay (eof has not been encountered).
*/
bool sungetb(bitfield &b)
{
bool unget_succeeded;
if (gptr() == std::streampos(-1) || gptr() == eback())
{
bitfield dummy;
unget_succeeded = pbackfail(dummy);
}
else
{
gbump(-1);
unget_succeeded = atgptrb(b);
}
return unget_succeeded;
}
int strstreambuf::underflow()
{
char * tptr;
if (gptr() >= egptr())
{
// try to grow get area if we can...
if (egptr()<pptr())
{
tptr = base() + (gptr()-eback());
setg(base(),tptr,pptr());
}
if (gptr() >= egptr())
return EOF;
}
return (int)(unsigned char) *gptr();
}
LoggerMessage::LoggerMessage(LoggerMessage&& other)
: std::ostream(nullptr)
, std::streambuf()
, category(other.category)
, logLevel(other.logLevel)
, logger(other.logger)
, message(other.message)
, timestamp(boost::posix_time::microsec_clock::local_time())
, gotText(false) {
if (this != &other) {
_M_tie = nullptr;
_M_streambuf = nullptr;
//ios_base swap
std::swap(_M_streambuf_state, other._M_streambuf_state);
std::swap(_M_exception, other._M_exception);
std::swap(_M_flags, other._M_flags);
std::swap(_M_precision, other._M_precision);
std::swap(_M_width, other._M_width);
std::swap(_M_callbacks, other._M_callbacks);
std::swap(_M_ios_locale, other._M_ios_locale);
//ios_base swap
//streambuf swap
char *_Pfirst = pbase();
char *_Pnext = pptr();
char *_Pend = epptr();
char *_Gfirst = eback();
char *_Gnext = gptr();
char *_Gend = egptr();
setp(other.pbase(), other.epptr());
other.setp(_Pfirst, _Pend);
setg(other.eback(), other.gptr(), other.egptr());
other.setg(_Gfirst, _Gnext, _Gend);
std::swap(_M_buf_locale, other._M_buf_locale);
//streambuf swap
std::swap(_M_fill, other._M_fill);
std::swap(_M_tie, other._M_tie);
}
_M_streambuf = this;
}
int_type underflow()
{
// if there is still data, then return it
if ( gptr() < egptr() )
return static_cast<int_type>(*(reinterpret_cast<uint8_t const *>(gptr())));
assert ( gptr() == egptr() );
// number of bytes for putback buffer
uint64_t const putbackcopy = std::min(
static_cast<uint64_t>(gptr() - eback()),
putbackspace
);
// copy bytes
#if 0
std::copy(
gptr()-putbackcopy,
gptr(),
buffer.begin() + putbackspace - putbackcopy
);
#endif
std::memmove(
buffer.begin() + putbackspace - putbackcopy,
gptr()-putbackcopy,
putbackcopy
);
// load data
uint64_t const uncompressedsize = stream.readPart(
buffer.begin()+putbackspace,
buffer.size()-putbackspace
);
// set buffer pointers
setg(
buffer.begin()+putbackspace-putbackcopy,
buffer.begin()+putbackspace,
buffer.begin()+putbackspace+uncompressedsize
);
if ( uncompressedsize )
return static_cast<int_type>(*(reinterpret_cast<uint8_t const *>(gptr())));
else
return traits_type::eof();
}
streamsize stringbuf::_M_xsputnc(char_type __char, streamsize __count)
{
if (((__M_mode & ios_base::out) == 0) || (__count <= 0)) return 0;
streamsize __nwritten = 0;
// If the put pointer is somewhere in the middle of the string, then overwrite instead of append.
if (pbase() == __M_str.begin())
{
ptrdiff_t __avail = __M_str.end() - pptr();
if (__avail >= __count)
{
VOS_memset_s(pptr(), epptr() - pptr(), __char, static_cast<size_t>(__count));
pbump(static_cast<int>(__count));
return __count;
}
else
{
VOS_memset_s(pptr(), epptr() - pptr(), __char, __avail);
__nwritten += __avail;
__count -= __avail;
}
}
// At this point we know we're appending.
size_t __app_size = static_cast<size_t>(__count);
char_type* __data_ptr;
if (__M_mode & ios_base::in)
{
ptrdiff_t __get_offset = gptr() - eback();
__M_str.append(__app_size, __char);
__data_ptr = __M_str.begin();
setg(__data_ptr, __data_ptr + __get_offset, __M_str.end());
}
else
{
__M_str.append(__app_size, __char);
__data_ptr = __M_str.begin();
}
setp(__data_ptr, __M_str.end());
pbump(static_cast<int>(__M_str.size()));
__nwritten += __app_size;
return __nwritten;
}
streamsize stringbuf::xsputn(const char_type* __string, streamsize __length)
{
if (((__M_mode & ios_base::out) == 0) || (__length <= 0)) return 0;
streamsize __nwritten = 0;
// If the put pointer is somewhere in the middle of the string, then overwrite instead of append.
if (!__M_str.empty() && (pbase() == __M_str.begin()))
{
ptrdiff_t __avail = __M_str.end() - pptr();
if (__avail >= __length)
{
VOS_memcpy_s(pptr(), epptr() - pptr(), __string, static_cast<size_t>(__length));
pbump(static_cast<int>(__length));
return __length;
}
else
{
VOS_memcpy_s(pptr(), epptr() - pptr(), __string, __avail);
__nwritten += __avail;
__length -= __avail;
__string += __avail;
}
}
// At this point we know we're appending.
char_type* __data_ptr;
if (__M_mode & ios_base::in)
{
ptrdiff_t __get_offset = gptr() - eback();
__M_str.append(__string, __string + static_cast<ptrdiff_t>(__length));
__data_ptr = __M_str.begin();
setg(__data_ptr, __data_ptr + __get_offset, __M_str.end());
}
else
{
__M_str.append(__string, __string + static_cast<ptrdiff_t>(__length));
__data_ptr = __M_str.begin();
}
setp(__data_ptr, __M_str.end());
pbump(static_cast<int>(__M_str.size()));
__nwritten += __length;
return __nwritten;
}
void sockbuf::shutdown (shuthow sh)
{
switch (sh) {
case shut_read:
delete [] eback ();
setg (0, 0, 0);
break;
case shut_write:
delete [] pbase ();
setp (0, 0);
break;
case shut_readwrite:
shutdown (shut_read);
shutdown (shut_write);
break;
}
if (::shutdown(rep->sock, sh) == -1) throw sockerr (errno, "sockbuf::shutdown", sockname.text.c_str());
}
