reverted previous patch applied by mistake

[wxWidgets.git] / src / common / stream.cpp

diff --git a/src/common/stream.cpp b/src/common/stream.cpp
index 88a8ccc79023ebad60f7d25503d281a97b74c90c..1f72c00bd6226808dc8e0bdab23d563fb10bfb6f 100644 (file)
--- a/src/common/stream.cpp
+++ b/src/common/stream.cpp
@@ -7,7 +7,7 @@
 // Created:     11/07/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Guilhem Lavaux
 // Created:     11/07/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Guilhem Lavaux

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================


@@ -18,7 +18,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

     #pragma implementation "stream.h"
 #endif
 
     #pragma implementation "stream.h"
 #endif
 


@@ -46,7 +46,7 @@
 // ----------------------------------------------------------------------------
 
 // the temporary buffer size used when copying from stream to stream
 // ----------------------------------------------------------------------------
 
 // the temporary buffer size used when copying from stream to stream

-#define BUF_TEMP_SIZE 10000
+#define BUF_TEMP_SIZE 4096

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -58,7 +58,7 @@
 
 void wxStreamBuffer::SetError(wxStreamError err)
 {
 
 void wxStreamBuffer::SetError(wxStreamError err)
 {

-   if ( m_stream->m_lasterror == wxStream_NOERROR )
+   if ( m_stream && m_stream->m_lasterror == wxSTREAM_NO_ERROR )

        m_stream->m_lasterror = err;
 }
 
        m_stream->m_lasterror = err;
 }
 


@@ -80,40 +80,31 @@ void wxStreamBuffer::Init()
     m_fixed = TRUE;
 }
 
     m_fixed = TRUE;
 }
 

-wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
+wxStreamBuffer::wxStreamBuffer(BufMode mode)

 {
     Init();
 
 {
     Init();
 

-    m_stream = &stream;
+    m_stream = NULL;

     m_mode = mode;
 
     m_mode = mode;
 

-    m_flushable = TRUE;
-    m_destroystream = FALSE;
+    m_flushable = FALSE;

 }
 
 }
 

-wxStreamBuffer::wxStreamBuffer(BufMode mode)
+wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)

 {
     Init();
 
 {
     Init();
 

-    wxASSERT_MSG(mode != read_write, wxT("you have to use the other ctor for read_write mode") );
-    if ( mode == read )
-        m_stream = new wxInputStream;
-    else if ( mode == write)
-        m_stream = new wxOutputStream;
-    else
-        m_stream = NULL;
-
+    m_stream = &stream;

     m_mode = mode;
 
     m_mode = mode;
 

-    m_flushable = FALSE;
-    m_destroystream = TRUE;
+    m_flushable = TRUE;

 }
 
 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
 {
 }
 
 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
 {

-    // doing this has big chances to lead to a crashwhen the source buffer is
+    // doing this has big chances to lead to a crash when the source buffer is

     // destroyed (otherwise assume the caller knows what he does)
     // destroyed (otherwise assume the caller knows what he does)

-    wxASSERT_MSG( !buffer.m_destroybuf && !buffer.m_destroystream,
+    wxASSERT_MSG( !buffer.m_destroybuf,

                   _T("it's a bad idea to copy this buffer") );
 
     m_buffer_start = buffer.m_buffer_start;
                   _T("it's a bad idea to copy this buffer") );
 
     m_buffer_start = buffer.m_buffer_start;


@@ -125,7 +116,6 @@ wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
     m_stream = buffer.m_stream;
     m_mode = buffer.m_mode;
     m_destroybuf = FALSE;
     m_stream = buffer.m_stream;
     m_mode = buffer.m_mode;
     m_destroybuf = FALSE;

-    m_destroystream = FALSE;

 }
 
 void wxStreamBuffer::FreeBuffer()
 }
 
 void wxStreamBuffer::FreeBuffer()


@@ -137,9 +127,6 @@ void wxStreamBuffer::FreeBuffer()
 wxStreamBuffer::~wxStreamBuffer()
 {
     FreeBuffer();
 wxStreamBuffer::~wxStreamBuffer()
 {
     FreeBuffer();

-
-    if ( m_destroystream )
-        delete m_stream;

 }
 
 wxInputStream *wxStreamBuffer::GetInputStream() const
 }
 
 wxInputStream *wxStreamBuffer::GetInputStream() const


@@ -195,14 +182,15 @@ void wxStreamBuffer::SetBufferIO(size_t bufsize)
 
 void wxStreamBuffer::ResetBuffer()
 {
 
 void wxStreamBuffer::ResetBuffer()
 {

-    wxCHECK_RET( m_stream, _T("should have a stream in wxStreamBuffer") );
+    if ( m_stream )
+    {
+        m_stream->Reset();
+        m_stream->m_lastcount = 0;
+    }

 
 

-    m_stream->m_lasterror = wxStream_NOERROR;
-    m_stream->m_lastcount = 0;
-    if (m_mode == read && m_flushable)
-        m_buffer_pos = m_buffer_end;
-    else
-        m_buffer_pos = m_buffer_start;
+    m_buffer_pos = m_mode == read && m_flushable
+                        ? m_buffer_end
+                        : m_buffer_start;

 }
 
 // fill the buffer with as much data as possible (only for read buffers)
 }
 
 // fill the buffer with as much data as possible (only for read buffers)


@@ -210,7 +198,9 @@ bool wxStreamBuffer::FillBuffer()
 {
     wxInputStream *inStream = GetInputStream();
 
 {
     wxInputStream *inStream = GetInputStream();
 

-    wxCHECK_MSG( inStream, FALSE, _T("should have a stream in wxStreamBuffer") );
+    // It's legal to have no stream, so we don't complain about it just return FALSE
+    if ( !inStream )
+        return FALSE;

 
     size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);
     if ( !count )
 
     size_t count = inStream->OnSysRead(m_buffer_start, m_buffer_size);
     if ( !count )


@@ -271,6 +261,7 @@ void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size)
 void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
 {
     size_t left = GetBytesLeft();
 void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
 {
     size_t left = GetBytesLeft();

+

     if ( size > left )
     {
         if ( m_fixed )
     if ( size > left )
     {
         if ( m_fixed )


@@ -315,7 +306,7 @@ void wxStreamBuffer::PutChar(char c)
     // if we don't have buffer at all, just forward this call to the stream,
     if ( !HasBuffer() )
     {
     // if we don't have buffer at all, just forward this call to the stream,
     if ( !HasBuffer() )
     {

-        outStream->OnSysWrite(&c, 1);
+        outStream->OnSysWrite(&c, sizeof(c));

     }
     else
     {
     }
     else
     {


@@ -323,11 +314,11 @@ void wxStreamBuffer::PutChar(char c)
         if ( !GetDataLeft() && !FlushBuffer() )
         {
             // we don't
         if ( !GetDataLeft() && !FlushBuffer() )
         {
             // we don't

-            SetError(wxStream_WRITE_ERR);
+            SetError(wxSTREAM_WRITE_ERROR);

         }
         else
         {
         }
         else
         {

-            PutToBuffer(&c, 1);
+            PutToBuffer(&c, sizeof(c));

             m_stream->m_lastcount = 1;
         }
     }
             m_stream->m_lastcount = 1;
         }
     }


@@ -340,12 +331,12 @@ char wxStreamBuffer::Peek()
 
     if ( !GetDataLeft() )
     {
 
     if ( !GetDataLeft() )
     {

-        SetError(wxStream_READ_ERR);
+        SetError(wxSTREAM_READ_ERROR);

         return 0;
     }
 
     char c;
         return 0;
     }
 
     char c;

-    GetFromBuffer(&c, 1);
+    GetFromBuffer(&c, sizeof(c));

     m_buffer_pos--;
 
     return c;
     m_buffer_pos--;
 
     return c;


@@ -360,18 +351,18 @@ char wxStreamBuffer::GetChar()
     char c;
     if ( !HasBuffer() )
     {
     char c;
     if ( !HasBuffer() )
     {

-        inStream->OnSysRead(&c, 1);
+        inStream->OnSysRead(&c, sizeof(c));

     }
     else
     {
         if ( !GetDataLeft() )
         {
     }
     else
     {
         if ( !GetDataLeft() )
         {

-            SetError(wxStream_READ_ERR);
+            SetError(wxSTREAM_READ_ERROR);

             c = 0;
         }
         else
         {
             c = 0;
         }
         else
         {

-            GetFromBuffer(&c, 1);
+            GetFromBuffer(&c, sizeof(c));

             m_stream->m_lastcount = 1;
         }
     }
             m_stream->m_lastcount = 1;
         }
     }


@@ -381,16 +372,18 @@ char wxStreamBuffer::GetChar()
 
 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 {
 
 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 {

-    wxInputStream *inStream = GetInputStream();
-
-    wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
-

     // lasterror is reset before all new IO calls
     // lasterror is reset before all new IO calls

-    m_stream->m_lasterror = wxStream_NOERROR;
+    if ( m_stream )
+        m_stream->Reset();

 
 

+    size_t read;

     if ( !HasBuffer() )
     {
     if ( !HasBuffer() )
     {

-        m_stream->m_lastcount = inStream->OnSysRead(buffer, size);
+        wxInputStream *inStream = GetInputStream();
+
+        wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
+
+        read = inStream->OnSysRead(buffer, size);

     }
     else // we have a buffer, use it
     {
     }
     else // we have a buffer, use it
     {


@@ -410,7 +403,7 @@ size_t wxStreamBuffer::Read(void *buffer, size_t size)
 
                 if ( !FillBuffer() )
                 {
 
                 if ( !FillBuffer() )
                 {

-                    SetError(wxStream_EOF);
+                    SetError(wxSTREAM_EOF);

                     break;
                 }
             }
                     break;
                 }
             }


@@ -421,10 +414,13 @@ size_t wxStreamBuffer::Read(void *buffer, size_t size)
             }
         }
 
             }
         }
 

-        m_stream->m_lastcount = orig_size - size;
+        read = orig_size - size;

     }
 
     }
 

-    return m_stream->m_lastcount;
+    if ( m_stream )
+        m_stream->m_lastcount = read;
+
+    return read;

 }
 
 // this should really be called "Copy()"
 }
 
 // this should really be called "Copy()"


@@ -452,17 +448,22 @@ size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
 
 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 {
 
 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 {

-    wxOutputStream *outStream = GetOutputStream();
+    if (m_stream)
+    {
+        // lasterror is reset before all new IO calls
+        m_stream->Reset();
+    }

 
 

-    wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
-
-    // lasterror is reset before all new IO calls
-    m_stream->m_lasterror = wxStream_NOERROR;
+    size_t ret;

 
     if ( !HasBuffer() && m_fixed )
     {
 
     if ( !HasBuffer() && m_fixed )
     {

+        wxOutputStream *outStream = GetOutputStream();
+
+        wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
+

         // no buffer, just forward the call to the stream
         // no buffer, just forward the call to the stream

-        m_stream->m_lastcount = outStream->OnSysWrite(buffer, size);
+        ret = outStream->OnSysWrite(buffer, size);

     }
     else // we [may] have a buffer, use it
     {
     }
     else // we [may] have a buffer, use it
     {


@@ -480,6 +481,7 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size)
             //
             // FIXME: fine, but if it fails we should (re)try writing it by
             //        chunks as this will (hopefully) always work (VZ)
             //
             // FIXME: fine, but if it fails we should (re)try writing it by
             //        chunks as this will (hopefully) always work (VZ)

+

             if ( size > left && m_fixed )
             {
                 PutToBuffer(buffer, left);
             if ( size > left && m_fixed )
             {
                 PutToBuffer(buffer, left);


@@ -488,7 +490,7 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 
                 if ( !FlushBuffer() )
                 {
 
                 if ( !FlushBuffer() )
                 {

-                    SetError(wxStream_WRITE_ERR);
+                    SetError(wxSTREAM_WRITE_ERROR);

 
                     break;
                 }
 
                     break;
                 }


@@ -502,10 +504,16 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size)
             }
         }
 
             }
         }
 

-        m_stream->m_lastcount = orig_size - size;
+        ret = orig_size - size;
+    }
+
+    if (m_stream)
+    {
+        // i am not entirely sure what we do this for
+        m_stream->m_lastcount = ret;

     }
 
     }
 

-    return m_stream->m_lastcount;
+    return ret;

 }
 
 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
 }
 
 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)


@@ -613,9 +621,19 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
 
 off_t wxStreamBuffer::Tell() const
 {
 
 off_t wxStreamBuffer::Tell() const
 {

-    off_t pos = m_stream->OnSysTell();
-    if ( pos == wxInvalidOffset )
-        return wxInvalidOffset;
+    off_t pos;
+
+    // ask the stream for position if we have a real one
+    if ( m_stream )
+    {
+        pos = m_stream->OnSysTell();
+        if ( pos == wxInvalidOffset )
+            return wxInvalidOffset;
+    }
+    else // no associated stream
+    {
+        pos = 0;
+    }

 
     pos += GetIntPosition();
 
 
     pos += GetIntPosition();
 


@@ -631,7 +649,7 @@ off_t wxStreamBuffer::Tell() const
 
 wxStreamBase::wxStreamBase()
 {
 
 wxStreamBase::wxStreamBase()
 {

-    m_lasterror = wxStream_NOERROR;
+    m_lasterror = wxSTREAM_NO_ERROR;

     m_lastcount = 0;
 }
 
     m_lastcount = 0;
 }
 


@@ -665,31 +683,19 @@ wxInputStream::~wxInputStream()
     free(m_wback);
 }
 
     free(m_wback);
 }
 

-size_t wxInputStream::OnSysRead(void * WXUNUSED(buffer),
-                                size_t WXUNUSED(bufsize))
+bool wxInputStream::CanRead() const

 {
 {

-    return 0;
+    // we don't know if there is anything to read or not and by default we
+    // prefer to be optimistic and try to read data unless we know for sure
+    // there is no more of it
+    return m_lasterror != wxSTREAM_EOF;

 }
 
 bool wxInputStream::Eof() const
 {
 }
 
 bool wxInputStream::Eof() const
 {

-    wxInputStream *self = wxConstCast(this, wxInputStream);
-
-    char c;
-    self->Read(&c, 1);
-
-    // some streams can know that they're at EOF before actually trying to
-    // read beyond the end of stream (e.g. files) while others have no way of
-    // knowing it, so to provide the same behaviour in all cases we only
-    // return TRUE from here if the character really couldn't be read
-    if ( !self->LastRead() && GetLastError() == wxSTREAM_EOF )
-    {
-        return TRUE;
-    }
-
-    self->Ungetch(c);
-
-    return FALSE;
+    // the only way the base class can know we're at EOF is when we'd already
+    // tried to read beyond it in which case last error is set accordingly
+    return GetLastError() == wxSTREAM_EOF;

 }
 
 char *wxInputStream::AllocSpaceWBack(size_t needed_size)
 }
 
 char *wxInputStream::AllocSpaceWBack(size_t needed_size)


@@ -718,7 +724,7 @@ char *wxInputStream::AllocSpaceWBack(size_t needed_size)
     return m_wback;
 }
 
     return m_wback;
 }
 

-size_t wxInputStream::GetWBack(void *buf, size_t bsize)
+size_t wxInputStream::GetWBack(void *buf, size_t size)

 {
     if (!m_wback)
         return 0;
 {
     if (!m_wback)
         return 0;


@@ -726,13 +732,13 @@ size_t wxInputStream::GetWBack(void *buf, size_t bsize)
     // how many bytes do we have in the buffer?
     size_t toget = m_wbacksize - m_wbackcur;
 
     // how many bytes do we have in the buffer?
     size_t toget = m_wbacksize - m_wbackcur;
 

-    if ( bsize < toget )
+    if ( size < toget )

     {
         // we won't read everything
     {
         // we won't read everything

-        toget = bsize;
+        toget = size;

     }
 
     }
 

-    // copy the data from the cache 
+    // copy the data from the cache

     memcpy(buf, m_wback + m_wbackcur, toget);
 
     m_wbackcur += toget;
     memcpy(buf, m_wback + m_wbackcur, toget);
 
     m_wbackcur += toget;


@@ -751,52 +757,77 @@ size_t wxInputStream::GetWBack(void *buf, size_t bsize)
 
 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 {
 
 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 {

+    if ( m_lasterror != wxSTREAM_NO_ERROR && m_lasterror != wxSTREAM_EOF )
+    {
+        // can't operate on this stream until the error is cleared
+        return 0;
+    }
+

     char *ptrback = AllocSpaceWBack(bufsize);
     if (!ptrback)
         return 0;
 
     char *ptrback = AllocSpaceWBack(bufsize);
     if (!ptrback)
         return 0;
 

+    // Eof() shouldn't return TRUE any longer
+    if ( m_lasterror == wxSTREAM_EOF )
+        m_lasterror = wxSTREAM_NO_ERROR;
+

     memcpy(ptrback, buf, bufsize);
     return bufsize;
 }
 
 bool wxInputStream::Ungetch(char c)
 {
     memcpy(ptrback, buf, bufsize);
     return bufsize;
 }
 
 bool wxInputStream::Ungetch(char c)
 {

-    void *ptrback = AllocSpaceWBack(1);
-    if (!ptrback)
-        return FALSE;
-
-    *(char *)ptrback = c;
-    return TRUE;
+    return Ungetch(&c, sizeof(c)) != 0;

 }
 
 char wxInputStream::GetC()
 {
     char c;
 }
 
 char wxInputStream::GetC()
 {
     char c;

-    Read(&c, 1);
+    Read(&c, sizeof(c));

     return c;
 }
 
 wxInputStream& wxInputStream::Read(void *buf, size_t size)
 {
     return c;
 }
 
 wxInputStream& wxInputStream::Read(void *buf, size_t size)
 {

-    size_t retsize = GetWBack(buf, size);
-    if (retsize == size)
+    char *p = (char *)buf;
+    m_lastcount = 0;
+
+    size_t read = GetWBack(buf, size);
+    for ( ;; )

     {
     {

-        m_lastcount = size;
-        m_lasterror = wxStream_NOERROR;
-        return *this;
+        size -= read;
+        m_lastcount += read;
+        p += read;
+
+        if ( !size )
+        {
+            // we read the requested amount of data
+            break;
+        }
+
+        if ( p != buf && !CanRead() )
+        {
+            // we have already read something and we would block in OnSysRead()
+            // now: don't do it but return immediately
+            break;
+        }
+
+        read = OnSysRead(p, size);
+        if ( !read )
+        {
+            // no more data available
+            break;
+        }

     }
     }

-    size -= retsize;
-    buf = (char *)buf + retsize;

 
 

-    m_lastcount = OnSysRead(buf, size) + retsize;

     return *this;
 }
 
 char wxInputStream::Peek()
 {
     char c;
     return *this;
 }
 
 char wxInputStream::Peek()
 {
     char c;

-    Read(&c, 1);
-    if (m_lasterror == wxStream_NOERROR)
+    Read(&c, sizeof(c));
+    if (m_lasterror == wxSTREAM_NO_ERROR)

     {
         Ungetch(c);
         return c;
     {
         Ungetch(c);
         return c;


@@ -808,13 +839,17 @@ char wxInputStream::Peek()
 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 {
     char buf[BUF_TEMP_SIZE];
 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 {
     char buf[BUF_TEMP_SIZE];

-    size_t bytes_read = BUF_TEMP_SIZE;

 
 

-    while (bytes_read == BUF_TEMP_SIZE)
+    for ( ;; )

     {
     {

-        bytes_read = Read(buf, bytes_read).LastRead();
-        bytes_read = stream_out.Write(buf, bytes_read).LastWrite();
+        size_t bytes_read = Read(buf, WXSIZEOF(buf)).LastRead();
+        if ( !bytes_read )
+            break;
+
+        if ( stream_out.Write(buf, bytes_read).LastWrite() != bytes_read )
+            break;

     }
     }

+

     return *this;
 }
 
     return *this;
 }
 


@@ -827,7 +862,7 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
 
     // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
     if (m_lasterror==wxSTREAM_EOF)
 
     // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
     if (m_lasterror==wxSTREAM_EOF)

-        m_lasterror=wxSTREAM_NOERROR;
+        m_lasterror=wxSTREAM_NO_ERROR;

 
     /* RR: A call to SeekI() will automatically invalidate any previous
        call to Ungetch(), otherwise it would be possible to SeekI() to
 
     /* RR: A call to SeekI() will automatically invalidate any previous
        call to Ungetch(), otherwise it would be possible to SeekI() to


@@ -838,11 +873,11 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
        buffer if possible, but is it really needed? It would only work
        when seeking in wxFromCurrent mode, else it would invalidate
        anyway... */
        buffer if possible, but is it really needed? It would only work
        when seeking in wxFromCurrent mode, else it would invalidate
        anyway... */

-       
+

     if (m_wback)
     {
         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
     if (m_wback)
     {
         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );

-        
+

         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;


@@ -883,7 +918,7 @@ size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
 
 void wxOutputStream::PutC(char c)
 {
 
 void wxOutputStream::PutC(char c)
 {

-    Write(&c, 1);
+    Write(&c, sizeof(c));

 }
 
 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
 }
 
 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)


@@ -1042,7 +1077,7 @@ char wxBufferedInputStream::Peek()
 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
 {
     // reset the error flag
 wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
 {
     // reset the error flag

-    m_lasterror = wxStream_NOERROR;
+    Reset();

 
     // first read from the already cached data
     m_lastcount = GetWBack(buf, size);
 
     // first read from the already cached data
     m_lastcount = GetWBack(buf, size);


@@ -1070,18 +1105,18 @@ off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
     // RR: Look at wxInputStream for comments.
 
     if (m_lasterror==wxSTREAM_EOF)
     // RR: Look at wxInputStream for comments.
 
     if (m_lasterror==wxSTREAM_EOF)

-        m_lasterror=wxSTREAM_NOERROR;
+        Reset();

 
     if (m_wback)
     {
         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
 
     if (m_wback)
     {
         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );

-        
+

         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
         m_wbackcur = 0;
     }

-    
+

     return m_i_streambuf->Seek(pos, mode);
 }
 
     return m_i_streambuf->Seek(pos, mode);
 }
 


@@ -1091,7 +1126,7 @@ off_t wxBufferedInputStream::TellI() const
 
     if (pos != wxInvalidOffset)
         pos -= (m_wbacksize - m_wbackcur);
 
     if (pos != wxInvalidOffset)
         pos -= (m_wbacksize - m_wbackcur);

-        
+

     return pos;
 }
 
     return pos;
 }