std::streamsize sockstreambuf_kernel_2::
xsgetn (
char_type* s,
std::streamsize n
)
{
std::streamsize temp = n;
while (n > 0)
{
int num = static_cast<int>(egptr() - gptr());
if (num >= n)
{
// copy data from our buffer
std::memcpy(s, gptr(), static_cast<size_t>(n));
gbump(static_cast<int>(n));
return temp;
}
// read more data into our buffer
if (num == 0)
{
if (underflow() == EOF)
break;
continue;
}
// copy all the data from our buffer
std::memcpy(s, gptr(), num);
n -= num;
gbump(num);
s += num;
}
return temp-n;
}
stringbuf::int_type stringbuf::pbackfail(int_type __char)
{
if (gptr() == eback()) return EOF;
STL_ASSERT(gptr() > eback());
if (__char == EOF)
{
gbump(-1);
return 0;
}
if (static_cast<char_type>(__char) == gptr()[-1])
{
gbump(-1);
return __char;
}
if (__M_mode & ios_base::out) // 要放回的字符与流中的不同，覆盖掉流中的字符。
{
gbump(-1);
*gptr() = static_cast<char_type>(__char);
return __char;
}
return EOF;
}
streamsize streambuf::do_sgetn( char *buf, streamsize len ) {
streamsize available;
streamsize returned;
returned = 0;
__lock_it( __b_lock );
while( len > 0 ) {
// # characters left in buffer
available = (__huge_ptr_int)(egptr() - gptr());
if( available <= 0 ) { // nothing left?
if( underflow() == EOF ) break;
available = (__huge_ptr_int)(egptr() - gptr());
}
if( available > len ) { // too many?
available = len;
}
memcpy( buf, gptr(), available );
gbump( available );
returned += available;
buf += available;
len -= available;
}
return( returned );
}
int pbackfail(int c)
{
if(c==EOF)
return EOF;
if(gptr()!=eback()) {
gbump(-1);
*gptr() = c;
return 0;
}
if(pback_buffer_.empty()) {
pback_buffer_.resize(4);
char *b = &pback_buffer_[0];
char *e = b + pback_buffer_.size();
setg(b,e-1,e);
*gptr() = c;
}
else {
size_t n = pback_buffer_.size();
std::vector<char> tmp;
tmp.resize(n*2);
memcpy(&tmp[n],&pback_buffer_[0],n);
tmp.swap(pback_buffer_);
char *b = &pback_buffer_[0];
char *e = b + n * 2;
char *p = b+n-1;
*p = c;
setg(b,p,e);
}
return 0;
}
//read to buffer in place (apart from data already buffered)
std::streamsize istreambuf::xsgetn(char *buffer, std::streamsize n) {
LOG("bz::istreambuf::xsgetn (" << n << ")");
//try to satisfy request from buffered input
std::streamsize available = egptr() - gptr();
int read = (available >= n)? n : available;
if (read) {
std::copy(gptr(), gptr() + read, buffer);
gbump(read);
}
//inflate the rest directly into the user's buffer
if (read < n) {
if (end) {
LOG("\tend of stream (EOF)");
//signal the stream has reached it's end
return eof;
}
z_strm->next_out = buffer + read;
z_strm->avail_out = n - read;
if (0 < z_strm->avail_in) {
decompress();
}
while (!(end || 0 == z_strm->avail_out)) {
read_decompress();
}
underflow();
}
return n;
}
_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));
}
// ---------
streamsize CEEStdStreamBufProxy::xsgetn(TCHAR *dest, streamsize sSize)
{
int nRead = 0;
int avail;
while (sSize)
{
// get number of character available
avail = in_avail();
if (!avail)
{
if (underflow() == EOF)
break;
}
if (avail > sSize)
{
avail = sSize;
}
memcpy(dest + nRead, gptr(), avail);
gbump(avail);
nRead += avail;
sSize -= avail;
}
return nRead;
}
/**
* Removes @c n characters from the beginning of the input sequence.
*
* @throws std::length_error If <tt>n > size()</tt>.
*/
void consume(std::size_t n)
{
if (egptr() < pptr())
setg(&buffer_[0], gptr(), pptr());
if (gptr() + n > pptr())
n = pptr() - gptr();
gbump(static_cast<int>(n));
}
std::streamsize sockbuf::xsgetn (char_type* s, std::streamsize n)
{
std::streamsize rval = showmanyc ();
if (rval >= n) {
memcpy (s, gptr (), (size_t)(n * sizeof (char_type)));
gbump ((int)n);
return n;
}
memcpy (s, gptr (), (size_t)(rval * sizeof (char_type)));
gbump ((int)rval);
if (underflow () != eof)
return rval + xsgetn (s + rval, n - rval);
return rval;
}
streamsize mem_streambuf::xsgetn( char_type *buf, std::streamsize size ) {
streamsize const remaining = showmanyc();
if ( size > remaining )
size = remaining;
::memcpy( buf, gptr(), static_cast<size_t>( size ) );
gbump( static_cast<int>(size) );
return size;
}
std::streamsize
ProcReader::xsgetn(char_type* ptr, std::streamsize num)
{
std::streamsize howMany = showmanyc();
if (num < howMany) {
memcpy(ptr, gptr(), num * sizeof(char_type));
gbump(num);
return num;
}
memcpy(ptr, gptr(), howMany * sizeof(char_type));
gbump(howMany);
if (traits_type::eof() == underflow())
return howMany;
return howMany + xsgetn(ptr + howMany, num - howMany);
}
sockbuf::int_type sockbuf::uflow ()
{
int_type ret = underflow ();
if (ret == eof)
return eof;
gbump (1);
return ret;
}
streambuf::int_type streambuf::pbackfail( int_type c ) {
if ( !traits_type::eq_int_type( c, traits_type::eof() ) &&
gptr() > eback() ) {
c = orig_buf_->sputbackc( traits_type::to_char_type( c ) );
if ( !traits_type::eq_int_type( c, traits_type::eof() ) )
gbump( -1 );
return c;
}
return traits_type::eof();
}
// Precondition: gptr() >= egptr().
stringbuf::int_type stringbuf::uflow()
{
if (gptr() < egptr())
{
int_type __char = static_cast<int_type>(*gptr());
gbump(1);
return __char;
}
return EOF;
}
int streambuf::sgetn(char* s, int n)
{
if( n <= (egptr_ - gptr_) )
{
memcpy(s, gptr_, n);
gbump(n);
return n;
}
return do_sgetn(s, n);
}
strstreambuf::int_type strstreambuf::pbackfail(int_type c) {
if (gptr() != eback()) {
if (c == traits_type::eof()) {
gbump(-1);
return traits_type::not_eof(c);
}
else if (c == gptr()[-1]) {
gbump(-1);
return c;
}
else if (!_M_constant) {
gbump(-1);
*gptr() = traits_type::to_char_type(c);
return c;
}
}
return traits_type::eof();
}
int
streambuf::sungetc()
{
if (mgbeg == 0 || mgnext == mgbeg)
{
return ios_base::failbit;
}
gbump(-1);
return traits::to_int(*gptr());
}
_STLP_EXP_DECLSPEC strstreambuf::int_type strstreambuf::pbackfail(int_type c)
{
if (gptr() != eback()) {
if (c == _Traits::eof()) {
gbump(-1);
return _Traits::not_eof(c);
}
else if (c == gptr()[-1]) {
gbump(-1);
return c;
}
else if (!_M_constant) {
gbump(-1);
*gptr() = c;
return c;
}
}
return _Traits::eof();
}
strstreambuf::int_type
strstreambuf::pbackfail(int_type c)
{
if (eback() == gptr())
return char_traits<char>::eof();
if (c != char_traits<char>::eof() && static_cast<char>(c) != gptr()[-1])
if (_CS_m_constant == 1)
return char_traits<char>::eof();
else
gptr()[-1] = static_cast<char>(c);
else
{
gbump(-1);
return 0;
}
gbump(-1);
return c;
}
std::streamsize filedescriptor_streambuf::xsgetn(
char *target, std::streamsize count)
{
std::streamsize available = showmanyc();
if(count <= available)
{
memcpy(target, gptr(), count * sizeof(char_type));
gbump(count);
return count;
}
memcpy(target, gptr(), available * sizeof(char_type));
gbump(available);
if(traits_type::eof() == underflow())
return available;
return (available + xsgetn(target+available, count-available));
}
int TCPStream::uflow()
{
int ret = underflow();
if (ret == EOF)
return EOF;
if (bufsize != 1)
gbump(1);
return ret;
}
/* virtual */ strstreambuf::int_type
strstreambuf::pbackfail (int_type c)
{
_RWSTD_ASSERT (_C_is_valid ());
typedef traits_type Traits;
if (eback () < gptr ()) {
// putback position is available (see 27.5.1, p3, bullet 3)
if (Traits::eq_int_type (c, Traits::eof ())) {
// D.7.1.3, p6, bullet 3
gbump (-1);
return Traits::not_eof (c);
}
if (Traits::eq_int_type (Traits::to_int_type (*(gptr () - 1)), c)) {
// D.7.1.3, p6, bullet 1
gbump (-1);
return c;
}
if (!(_C_state & _C_constant)) {
// D.7.1.3, p6, bullet 2
gbump (-1);
Traits::assign (*gptr (), Traits::to_char_type (c));
return c;
}
}
// D.7.1.3, p7
return Traits::eof ();
}
_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::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;
}
int
streambuf::sputbackc(char c)
{
#if defined(OS_INCLUDE_STREAMBUF_BUFFERS)
if (mgbeg == 0 || mgnext == mgbeg || !traits::eq(c, gptr()[-1]))
{
return pbackfail(traits::to_int(c));
}
gbump(-1);
return traits::to_int(*gptr());
#else
c = c;
return traits::eof();
#endif
}
streamsize streambuf::xsgetn( char_type *to, streamsize size ) {
streamsize return_size = 0;
if ( streamsize const gsize = egptr() - gptr() ) {
streamsize const n = min( gsize, size );
traits_type::copy( to, gptr(), static_cast<size_t>( n ) );
gbump( static_cast<int>( n ) );
to += n;
size -= n, return_size += n;
}
while ( size > 0 ) {
curl_io( &gbuf_.len_ );
if ( !gbuf_.len_ )
break;
setg( gbuf_.ptr_, gbuf_.ptr_, gbuf_.ptr_ + gbuf_.len_ );
streamsize const n = min( static_cast<streamsize>(gbuf_.len_), size );
traits_type::copy( to, gptr(), static_cast<size_t>(n) );
gbump( static_cast<int>( n ) );
to += n;
size -= n, return_size += n;
}
return return_size;
}
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));
}
/**
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
streambuf::sbumpc()
{
#if defined(OS_INCLUDE_STREAMBUF_BUFFERS)
if (mgbeg == 0)
return traits::eof();
if (mgnext == mgend)
{
return uflow();
}
int retval = traits::to_int(*gptr());
gbump(1);
return retval;
#else
return traits::eof();
#endif
}
