strstreambuf::pos_type
strstreambuf::seekoff(off_type off, ios_base::seekdir dir, ios_base::openmode which)
{
if (dir == ios_base::cur && (which & (ios_base::in | ios_base::out)) == (ios_base::in | ios_base::out)
|| (which & (ios_base::in | ios_base::out)) == 0)
return pos_type(-1);
off_type newoff = 0;
if (dir == ios_base::cur)
newoff = ((which & ios_base::in) != 0? gptr(): pptr()) - eback();
else
newoff = (epptr() == 0? egptr(): epptr()) - eback();
if (newoff + off < gptr() - eback() || newoff + off >= epptr() - eback())
return pos_type(-1);
if (which & ios_base::in)
if (gptr() == 0)
return pos_type(-1);
else
setg(eback(), eback() + newoff + off, egptr());
if (which & ios_base::out)
if (pptr() == 0)
return pos_type(-1);
else
setp(eback() + newoff + off, epptr());
return newoff + off;
}
streamsize CCompressionStreambuf::xsputn(const CT_CHAR_TYPE* buf,
streamsize count)
{
// Check processor's state
if ( !IsStreamProcessorOkay(CCompressionStream::eWrite) ) {
return CT_EOF;
}
if ( m_Writer->m_State == CSP::eFinalize ) {
return CT_EOF;
}
// Check parameters
if ( !buf || count <= 0 ) {
return 0;
}
// The number of chars copied
streamsize done = 0;
// Loop until no data is left
while ( done < count ) {
// Get the number of chars to write in this iteration
// (we've got one more char than epptr thinks)
size_t block_size = min(size_t(count-done), size_t(epptr()-pptr()+1));
// Write them
memcpy(pptr(), buf + done, block_size);
// Update the write pointer
pbump((int)block_size);
// Process block if necessary
if ( pptr() >= epptr() && !ProcessStreamWrite() ) {
break;
}
done += block_size;
}
return done;
};
strstreambuf::int_type
strstreambuf::overflow (int_type c)
{
if (c == char_traits<char>::eof())
return ' ';
if (pptr() == epptr())
{
if (_CS_m_dynamic == 0 || _CS_m_frozen == 1)
return char_traits<char>::eof();
streamsize n = epptr() - eback();
char* tmp = _CS_m_alloc == 0
? new char[n + _CS_m_chunk_size]
: static_cast<char*>(_CS_m_alloc(n + _CS_m_chunk_size));
char_traits<char>::copy(tmp, eback(), n);
char* del = eback();
setg(tmp, tmp + (gptr() - del), tmp + (egptr() - del));
setp(tmp + (pptr() - del), tmp + n + _CS_m_chunk_size);
if (_CS_m_allocated != 0)
_CS_m_free == 0? delete[] del: _CS_m_free(del);
_CS_m_allocated = 1;
}
*pptr() = static_cast<unsigned char>(c);
pbump(1);
return c;
}
strstreambuf::pos_type
strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
{
off_type __p(-1);
bool pos_in = (__which & ios::in) != 0;
bool pos_out = (__which & ios::out) != 0;
if (pos_in || pos_out)
{
if (!((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr)))
{
off_type newoff = __sp;
char* seekhigh = epptr() ? epptr() : egptr();
if (0 <= newoff && newoff <= seekhigh - eback())
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, _VSTD::max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
off_type temp = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
pbump(static_cast<int>((epptr() - pbase()) - temp));
}
__p = newoff;
}
}
}
return pos_type(__p);
}
int strstreambuf::overflow(int c)
{
/*
- if no room and not dynamic, give error
- if no room and dynamic, allocate (1 more or min) and store
- if and when the buffer has room, store c if not EOF
*/
int temp;
if (pptr() >= epptr())
{
if (!x_dynamic)
return EOF;
if (strstreambuf::doallocate()==EOF)
return EOF;
if (!epptr()) // init if first time through
{
setp(base() + (egptr() - eback()),ebuf());
}
else
{
temp = pptr()-pbase();
setp(pbase(),ebuf());
pbump(temp);
}
}
if (c!=EOF)
{
*pptr() = (char)c;
pbump(1);
}
return(1);
}
/**
* Appends @c n characters from the start of the output sequence to the input
* sequence. The beginning of the output sequence is advanced by @c n
* characters.
*
* Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
* no intervening operations that modify the input or output sequence.
*
* @throws std::length_error If @c n is greater than the size of the output
* sequence.
*/
void commit(std::size_t n)
{
if (pptr() + n > epptr())
n = epptr() - pptr();
pbump(static_cast<int>(n));
setg(eback(), gptr(), pptr());
}
strstreambuf::pos_type
strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which)
{
off_type __p(-1);
bool pos_in = (__which & ios::in) != 0;
bool pos_out = (__which & ios::out) != 0;
bool legal = false;
switch (__way)
{
case ios::beg:
case ios::end:
if (pos_in || pos_out)
legal = true;
break;
case ios::cur:
if (pos_in != pos_out)
legal = true;
break;
}
if (pos_in && gptr() == nullptr)
legal = false;
if (pos_out && pptr() == nullptr)
legal = false;
if (legal)
{
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:
return pos_type(off_type(-1));
}
newoff += __off;
if (0 <= newoff && newoff <= seekhigh - eback())
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, _VSTD::max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
__off = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
pbump(static_cast<int>((epptr() - pbase()) - __off));
}
__p = newoff;
}
}
return pos_type(__p);
}
int strstreambuf::overflow(int meta)
{ // try to extend write area
if (meta == EOF)
return (0); // nothing to write
else if (pptr() != 0 && pptr() < epptr())
return ((unsigned char)(*_Pninc() = meta)); // room in buffer
else if (!(_Strmode & _Dynamic)
|| _Strmode & (_Constant | _Frozen))
return (EOF); // can't extend
else
{ // okay to extend
int oldsize = gptr() == 0 ? 0 : epptr() - eback();
int newsize = oldsize;
int inc = newsize / 2 < _Minsize
? _Minsize : newsize / 2; // grow by 50 per cent if possible
_Minsize = _MINSIZE; // back to default for future growth
char *ptr = 0;
while (0 < inc && INT_MAX - inc < newsize)
inc /= 2; // reduce growth increment if too big
if (0 < inc)
{ // room to grow, increase size
newsize += inc;
ptr = _Palloc != 0 ? (char *)(*_Palloc)(newsize)
: _NEW_CRT char[newsize];
}
if (ptr == 0)
return (EOF); // couldn't grow, return failure
if (0 < oldsize)
memcpy(ptr, eback(), oldsize); // copy existing buffer
if (!(_Strmode & _Allocated))
; // no buffer to free
else if (_Pfree != 0)
(*_Pfree)(eback()); // free with function call
else
_DELETE_CRT_VEC(eback()); // free by deleting array
_Strmode |= _Allocated;
if (oldsize == 0)
{ // set up new buffer
_Seekhigh = ptr;
setp(ptr, ptr + newsize);
setg(ptr, ptr, ptr);
}
else
{ // revise old pointers
_Seekhigh = _Seekhigh - eback() + ptr;
setp(pbase() - eback() + ptr, pptr() - eback() + ptr,
ptr + newsize);
setg(ptr, gptr() - eback() + ptr, pptr() + 1);
}
return ((unsigned char)(*_Pninc() = meta));
}
std::ios::pos_type
Charbuf::seekoff(std::ios::off_type off, std::ios_base::seekdir dir,
std::ios_base::openmode which)
{
std::ios::pos_type pos;
char *cpos = nullptr;
if (which & std::ios_base::in)
{
switch (dir)
{
case std::ios::beg:
cpos = eback() + off - m_bufOffset;
break;
case std::ios::cur:
cpos = gptr() + off;
break;
case std::ios::end:
cpos = egptr() - off;
break;
default:
break; // Should never happen.
}
if (cpos < eback() || cpos > egptr())
return -1;
setg(eback(), cpos, egptr());
pos = cpos - eback();
}
if (which & std::ios_base::out)
{
switch (dir)
{
case std::ios::beg:
cpos = m_buf + off - m_bufOffset;
break;
case std::ios::cur:
cpos = pptr() + off;
break;
case std::ios::end:
cpos = egptr() - off;
break;
default:
break; // Should never happen.
}
if (cpos < m_buf || cpos > epptr())
return -1;
setp(cpos, epptr());
pos = cpos - m_buf;
}
return pos;
}
streampos strstreambuf::seekoff( streamoff offset,
ios::seekdir direction,
int mode ) {
streampos newpos;
char *endget;
char *pos;
mode &= (ios::in | ios::out);
if( (mode == 0) ||
( (direction==ios::cur) && (mode == (ios::in | ios::out)) ) ) {
return( EOF );
}
__lock_it( __b_lock );
// Move the get pointer:
if( mode & ios::in ) {
endget = pptr();
if( endget == NULL || endget < egptr() ) {
endget = egptr();
}
newpos = __get_position( offset, direction, eback(), gptr(), egptr(), endget );
if( newpos != EOF ) {
// If the seek went beyond the end of the get area, extend the
// get area to include the characters in the put area.
pos = eback() + newpos;
if( pos > egptr() ) {
setg( eback(), pos, epptr() );
} else {
setg( eback(), pos, egptr() );
}
}
}
if( mode & ios::out ) {
// Move the put pointer:
newpos = __get_position( offset, direction, pbase(), pptr(), epptr(), epptr() );
if( newpos != EOF ) {
setp( pbase(), epptr() );
pbump( newpos );
if( newpos > __minbuf_size ) {
__minbuf_size = (int)newpos;
}
}
}
return( newpos );
}
_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();
}
void sha1buf::update_sha1(uint32_t &H0, uint32_t &H1, uint32_t &H2, uint32_t &H3, uint32_t &H4)
{
uint64_t bits(len);
uint32_t *words = (uint32_t *) buf;
char *ptr = pptr(), *end = epptr();
bits += (ptr - pbase()) * 8;
std::ptrdiff_t pad = end + 1 - ptr;
if (pad) {
*ptr = '\x80';
if (pad >= 9)
end -= 8;
while (ptr++ < end)
*ptr = '\0';
if (pad < 9) {
_update_sha1(H0, H1, H2, H3, H4, words);
words = new uint32_t[16]();
}
words[15] = _BE(bits);
words[14] = _BE(((uint32_t *) &bits)[1]);
}
_update_sha1(H0, H1, H2, H3, H4, words);
}
stringbuf::int_type stringbuf::overflow(int_type __char)
{
if (__char == EOF) return 0; // __char is EOF, so we don't have to do anything
if (__M_mode & ios_base::out)
{
if (pptr() < epptr()) // just put back in any case
{
__M_str.push_back(static_cast<char_type>(__char));
pbump(1);
}
else if (__M_mode & ios_base::in)
{
ptrdiff_t __offset = gptr() - eback();
__M_str.push_back(static_cast<char_type>(__char));
char_type* __data_ptr = __M_str.begin();
setg(__data_ptr, __data_ptr + __offset, __M_str.end());
setp(__data_ptr, __M_str.end());
pbump(static_cast<int>(__M_str.size()));
}
else
{
__M_str.push_back(static_cast<char_type>(__char));
setp(__M_str.begin(), __M_str.end());
pbump(static_cast<int>(__M_str.size()));
}
return __char;
}
return EOF; // Overflow always fails if it's read-only
}
int _ALControlStream::overflow( int ch )
{
if ( !base() ) {
if ( allocate() == EOF )
return EOF;
setg( 0, 0, 0 );
} else {
if ( out_waiting() ) {
if ( sync() == EOF )
return EOF;
}
}
int bl = blen();
setp( base(), base() + bl - 2 );
if ( pptr() < epptr() ) {
*pptr() = (char) ch;
pbump( 1 );
} else {
*pptr() = (char ) ch;
pbump( 1 );
*pptr() = '\0';
pbump( 1 );
SendMessage( hWindow,
EM_REPLACESEL,
0,
(LPARAM) ( (LPSTR) pbase() ) );
}
return 0;
}
_CRTIMP2 streampos strstreambuf::seekpos(streampos sp,
ios::openmode which)
{ // seek to memorized position
streamoff off = (streamoff)sp;
if (pptr() != 0 && _Seekhigh < pptr())
_Seekhigh = pptr();
if (off == _BADOFF)
;
else if (which & ios::in && gptr() != 0)
{ // set input (and maybe output) pointer
if (0 <= off && off <= _Seekhigh - eback())
{ // set valid offset
gbump(eback() - gptr() + off);
if (which & ios::out && pptr() != 0)
setp(pbase(), gptr(), epptr());
}
else
off = _BADOFF;
}
else if (which & ios::out && pptr() != 0)
{ // set output pointer
if (0 <= off && off <= _Seekhigh - eback())
pbump(eback() - pptr() + off);
else
off = _BADOFF;
}
else // nothing to set
off = _BADOFF;
return (streampos(off));
}
std::streamsize LogBuf::xsputn(const Char8 *buffer, std::streamsize size)
{
if(size > 0)
{
if(!pptr())
return 0;
std::streamsize s = epptr() - pptr();
if(s >= size)
{
// Put it into the write buffer
memcpy(pptr(), buffer, size);
pbump(size);
}
else
{
// Flush write buffer
s = pptr() - pbase();
if (s > 0)
{
write(pbase(), s);
pbump(-s);
}
// Write data
write(buffer, size);
}
}
return size;
}
int rpcbuf::overflow(int c) {
if (!_opened || allocate() == EOF) {
return EOF;
}
if (c == EOF) {
finish_request();
}
if (rptr() == pbase() && pptr() >= epptr() && !expand_p()) {
error("rpcbuf::overflow: out of memory");
return EOF;
}
int nwrite = (rptr() >= pbase()) ? rptr() - pbase() : out_waiting();
int count = 0;
while (count < nwrite) {
int nsent = write(_fd, pbase() + count, nwrite - count);
if (nsent < 0) {
sys_error("rpcbuf::overflow: write");
return EOF;
}
count += nsent;
}
if (rptr() > pbase()) {
Memory::copy(rptr(), pbase(), pptr() - rptr());
rbump(-nwrite);
}
pbump(-nwrite);
if (c != EOF) {
sputc(c);
}
return zapeof(c);
}
int sync() {
if( pbase() != pptr() ) {
m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
setp( pbase(), epptr() );
}
return 0;
}
_STLP_EXP_DECLSPEC void strstreambuf::freeze(bool frozenflag)
{
#ifdef __SYMBIAN32__
if (_M_dynamic)
{
//
if (frozenflag && !_M_frozen)
{ // disable writing
_M_frozen = frozenflag;
_pfrozenendsave = epptr();
_pgetfrozenendsave = pptr();
setp(pbase(), eback());
}
else if (!frozenflag && _M_frozen)
{ // re-enable writing
_M_frozen = frozenflag;
if(_pfrozenendsave != NULL)
{
setp(pbase(), _pfrozenendsave);
setg(pbase(), pbase(), _pgetfrozenendsave);
}
}
}
#else
if (_M_dynamic)
_M_frozen = frozenflag;
#endif
}
std::streamsize xsputn(const char_type * s, std::streamsize n)
{
const char_type * end = s + n;
size_t c = std::min<size_t>(end - s, epptr() - pptr());
memcpy(pptr(), s, c);
pbump(static_cast<int>(c));
s += c;
if(s != end)
{
size_t c;
cur_->next = new Buffer;
cur_ = cur_->next;
for(;;)
{
c = std::min<size_t>(end - s, bufferSize);
memcpy(&cur_->data[0], s, c);
s += c;
if(s == end)
break;
cur_->next = new Buffer;
cur_ = cur_->next;
}
char * begin = &cur_->data[0];
std::streambuf::setp(begin + c, begin + bufferSize);
}
return n;
}
std::streamsize SimpleStreamBuf::xsputn(const char* s, std::streamsize n)
{
std::streamsize writeCount = 0;
while(writeCount < n)
{
char* current_pptr = pptr();
char* current_epptr = epptr();
if (current_pptr < current_epptr)
{
std::size_t copySize = (std::min)(static_cast< std::size_t >(n - writeCount),
static_cast< std::size_t >(current_epptr - current_pptr));
std::memcpy(current_pptr, s + writeCount, copySize);
writeCount += copySize;
setp(current_pptr + copySize, current_epptr);
setg(m_buffer, gptr(), pptr());
}
else if (overflow(std::char_traits< char >::to_int_type(*(s + writeCount))) != std::char_traits<char>::eof())
{
writeCount++;
}
else
{
return writeCount;
}
}
return writeCount;
}
ostream &
SMKStrStreambuf::dumpInfo(
ostream & dest,
const char * prefix,
bool showVer
)
{
if( showVer )
dest << SMKStrStreambuf::getClassName() << ":\n"
<< SMKStrStreambuf::getVersion() << '\n';
dest << prefix << "length: " << plen() << '\n'
#if defined( SMK_HAVE_STRBUF_BASE )
<< prefix << "base(): " << (void *) base() << '\n'
#endif
#if defined( SMK_HAVE_STRBUF_EBUF )
<< prefix << "ebuf(): " << (void *) ebuf() << '\n'
#endif
<< prefix << "pbase(): " << (void *) pbase() << '\n'
<< prefix << "pptr(): " << (void *) pptr() << '\n'
<< prefix << "epptr(): " << (void *) epptr() << '\n'
<< prefix << "eback(): " << (void *) eback() << '\n'
<< prefix << "gptr(): " << (void *) gptr() << '\n'
<< prefix << "egptr(): " << (void *) egptr() << '\n'
<< prefix << "n - b: " << pptr() - pbase() << '\n'
<< prefix << "string: '" << (void *)cstr() << "'\n"
<< prefix << "pbase(): " << (void *) pbase() << '\n'
<< prefix << "pptr(): " << (void *) pptr() << '\n'
<< prefix << "length: " << plen() << '\n'
<< prefix << "size: " << psize() << '\n'
;
return( dest );
}
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);
}
streamsize mem_streambuf::xsputn( char_type const *buf, streamsize size ) {
streamsize const remaining = epptr() - pptr();
if ( size > remaining )
size = remaining;
::memcpy( pptr(), buf, static_cast<size_t>( size ) );
pbump( static_cast<int>(size) );
return size;
}
virtual int_type overflow(int_type ch)
{
if(ch == traits_type::eof()) return traits_type::eof();
*epptr() = (char_type)L'\0';
sync();
sputc(ch);
return traits_type::not_eof(ch);
}
int HTTPChunkedStreamBuf::overflow(int c)
{
sync();
if (c != EOF && (pptr() < epptr())) { // guard against recursion
sputc(c);
}
return 0L; // return 0 if successful
}
std::streamsize xsputn (
const char* s,
std::streamsize num
)
{
// Add a sanity check here
DLIB_ASSERT(num >= 0,
"\tstd::streamsize filestreambuf::xsputn"
<< "\n\tThe number of bytes to write can't be negative"
<< "\n\tnum: " << num
<< "\n\tthis: " << this
);
std::streamsize space_left = static_cast<std::streamsize>(epptr()-pptr());
if (num <= space_left)
{
std::memcpy(pptr(),s,static_cast<size_t>(num));
pbump(static_cast<int>(num));
return num;
}
else
{
std::memcpy(pptr(),s,static_cast<size_t>(space_left));
s += space_left;
pbump(space_left);
std::streamsize num_left = num - space_left;
if (flush_out_buffer() == EOF)
{
// the write was not successful so return that 0 bytes were written
return 0;
}
if (num_left < out_buffer_size)
{
std::memcpy(pptr(),s,static_cast<size_t>(num_left));
pbump(num_left);
return num;
}
else
{
while(num_left != 0)
{
if(write_echoing_select(fd, fd_printf))
return EOF;
int status = write(fd,s,num_left);
if (status < 0)
{
// the write was not successful so return that 0 bytes were written
return 0;
}
num_left -= status;
s += status;
}
return num;
}
}
}
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;
}
mem_streambuf::int_type mem_streambuf::overflow( int_type c ) {
if ( traits_type::eq_int_type( c, traits_type::eof() ) )
return traits_type::not_eof( c );
if ( pptr() >= epptr() )
return traits_type::eof();
*pptr() = traits_type::to_char_type( c );
pbump( 1 );
return c;
}