X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9a76510b8a38e5b76acc4b647684b87ec11efd0a..b6afa1a38a78ac44ec984fbd211f658f2f80094b:/src/common/stream.cpp

diff --git a/src/common/stream.cpp b/src/common/stream.cpp
index a1d8cb04cc..271f7490ae 100644
--- 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
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // ============================================================================
@@ -18,7 +18,7 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
     #pragma implementation "stream.h"
 #endif
 
@@ -46,7 +46,7 @@
 // ----------------------------------------------------------------------------
 
 // the temporary buffer size used when copying from stream to stream
-#define BUF_TEMP_SIZE 10000
+#define BUF_TEMP_SIZE 4096
 
 // ============================================================================
 // implementation
@@ -58,7 +58,7 @@
 
 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;
 }
 
@@ -70,50 +70,41 @@ void wxStreamBuffer::InitBuffer()
     m_buffer_size = 0;
 
     // if we are going to allocate the buffer, we should free it later as well
-    m_destroybuf = TRUE;
+    m_destroybuf = true;
 }
 
 void wxStreamBuffer::Init()
 {
     InitBuffer();
 
-    m_fixed = TRUE;
+    m_fixed = true;
 }
 
-wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
+wxStreamBuffer::wxStreamBuffer(BufMode mode)
 {
     Init();
 
-    m_stream = &stream;
+    m_stream = NULL;
     m_mode = mode;
 
-    m_flushable = TRUE;
-    m_destroystream = FALSE;
+    m_flushable = false;
 }
 
-wxStreamBuffer::wxStreamBuffer(BufMode mode)
+wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
 {
     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_flushable = FALSE;
-    m_destroystream = TRUE;
+    m_flushable = true;
 }
 
 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)
-    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;
@@ -124,8 +115,7 @@ wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
     m_flushable = buffer.m_flushable;
     m_stream = buffer.m_stream;
     m_mode = buffer.m_mode;
-    m_destroybuf = FALSE;
-    m_destroystream = FALSE;
+    m_destroybuf = false;
 }
 
 void wxStreamBuffer::FreeBuffer()
@@ -137,9 +127,6 @@ void wxStreamBuffer::FreeBuffer()
 wxStreamBuffer::~wxStreamBuffer()
 {
     FreeBuffer();
-
-    if ( m_destroystream )
-        delete m_stream;
 }
 
 wxInputStream *wxStreamBuffer::GetInputStream() const
@@ -185,7 +172,7 @@ void wxStreamBuffer::SetBufferIO(size_t bufsize)
 
     if ( bufsize )
     {
-        SetBufferIO(malloc(bufsize), bufsize, TRUE /* take ownership */);
+        SetBufferIO(malloc(bufsize), bufsize, true /* take ownership */);
     }
     else // no buffer size => no buffer
     {
@@ -195,14 +182,15 @@ void wxStreamBuffer::SetBufferIO(size_t bufsize)
 
 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)
@@ -210,39 +198,41 @@ bool wxStreamBuffer::FillBuffer()
 {
     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 )
-        return FALSE;
+        return false;
 
     m_buffer_end = m_buffer_start + count;
     m_buffer_pos = m_buffer_start;
 
-    return TRUE;
+    return true;
 }
 
 // write the buffer contents to the stream (only for write buffers)
 bool wxStreamBuffer::FlushBuffer()
 {
-    wxCHECK_MSG( m_flushable, FALSE, _T("can't flush this buffer") );
+    wxCHECK_MSG( m_flushable, false, _T("can't flush this buffer") );
 
     // FIXME: what is this check for? (VZ)
     if ( m_buffer_pos == m_buffer_start )
-        return FALSE;
+        return false;
 
     wxOutputStream *outStream = GetOutputStream();
 
-    wxCHECK_MSG( outStream, FALSE, _T("should have a stream in wxStreamBuffer") );
+    wxCHECK_MSG( outStream, false, _T("should have a stream in wxStreamBuffer") );
 
     size_t current = m_buffer_pos - m_buffer_start;
     size_t count = outStream->OnSysWrite(m_buffer_start, current);
     if ( count != current )
-        return FALSE;
+        return false;
 
     m_buffer_pos = m_buffer_start;
 
-    return TRUE;
+    return true;
 }
 
 size_t wxStreamBuffer::GetDataLeft()
@@ -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();
+
     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() )
     {
-        outStream->OnSysWrite(&c, 1);
+        outStream->OnSysWrite(&c, sizeof(c));
     }
     else
     {
@@ -323,11 +314,11 @@ void wxStreamBuffer::PutChar(char c)
         if ( !GetDataLeft() && !FlushBuffer() )
         {
             // we don't
-            SetError(wxStream_WRITE_ERR);
+            SetError(wxSTREAM_WRITE_ERROR);
         }
         else
         {
-            PutToBuffer(&c, 1);
+            PutToBuffer(&c, sizeof(c));
             m_stream->m_lastcount = 1;
         }
     }
@@ -340,12 +331,12 @@ char wxStreamBuffer::Peek()
 
     if ( !GetDataLeft() )
     {
-        SetError(wxStream_READ_ERR);
+        SetError(wxSTREAM_READ_ERROR);
         return 0;
     }
 
     char c;
-    GetFromBuffer(&c, 1);
+    GetFromBuffer(&c, sizeof(c));
     m_buffer_pos--;
 
     return c;
@@ -360,18 +351,18 @@ char wxStreamBuffer::GetChar()
     char c;
     if ( !HasBuffer() )
     {
-        inStream->OnSysRead(&c, 1);
+        inStream->OnSysRead(&c, sizeof(c));
     }
     else
     {
         if ( !GetDataLeft() )
         {
-            SetError(wxStream_READ_ERR);
+            SetError(wxSTREAM_READ_ERROR);
             c = 0;
         }
         else
         {
-            GetFromBuffer(&c, 1);
+            GetFromBuffer(&c, sizeof(c));
             m_stream->m_lastcount = 1;
         }
     }
@@ -381,16 +372,18 @@ char wxStreamBuffer::GetChar()
 
 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
-    m_stream->m_lasterror = wxStream_NOERROR;
+    if ( m_stream )
+        m_stream->Reset();
 
+    size_t read;
     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
     {
@@ -410,7 +403,7 @@ size_t wxStreamBuffer::Read(void *buffer, size_t size)
 
                 if ( !FillBuffer() )
                 {
-                    SetError(wxStream_EOF);
+                    SetError(wxSTREAM_EOF);
                     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()"
@@ -452,17 +448,22 @@ size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
 
 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 {
-    wxOutputStream *outStream = GetOutputStream();
-
-    wxCHECK_MSG( outStream, 0, _T("should have a stream in wxStreamBuffer") );
+    if (m_stream)
+    {
+        // lasterror is reset before all new IO calls
+        m_stream->Reset();
+    }
 
-    // lasterror is reset before all new IO calls
-    m_stream->m_lasterror = wxStream_NOERROR;
+    size_t ret;
 
     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
-        m_stream->m_lastcount = outStream->OnSysWrite(buffer, size);
+        ret = outStream->OnSysWrite(buffer, size);
     }
     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)
+
             if ( size > left && m_fixed )
             {
                 PutToBuffer(buffer, left);
@@ -488,7 +490,7 @@ size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 
                 if ( !FlushBuffer() )
                 {
-                    SetError(wxStream_WRITE_ERR);
+                    SetError(wxSTREAM_WRITE_ERROR);
 
                     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;
     }
 
-    return m_stream->m_lastcount;
+    if (m_stream)
+    {
+        // i am not entirely sure what we do this for
+        m_stream->m_lastcount = ret;
+    }
+
+    return ret;
 }
 
 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
@@ -543,11 +551,11 @@ size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
     return total;
 }
 
-off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
+wxFileOffset wxStreamBuffer::Seek(wxFileOffset pos, wxSeekMode mode)
 {
-    off_t ret_off, diff;
+    wxFileOffset ret_off, diff;
 
-    off_t last_access = GetLastAccess();
+    wxFileOffset last_access = GetLastAccess();
 
     if ( !m_flushable )
     {
@@ -572,7 +580,9 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
         }
         if (diff < 0 || diff > last_access)
             return wxInvalidOffset;
-        SetIntPosition(diff);
+        size_t int_diff = (size_t)diff;
+        wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
+        SetIntPosition(int_diff);
         return diff;
     }
 
@@ -597,7 +607,9 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
             }
             else
             {
-                SetIntPosition(diff);
+                size_t int_diff = (size_t)diff;
+                wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
+                SetIntPosition(int_diff);
                 return pos;
             }
 
@@ -611,14 +623,12 @@ off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
     return wxInvalidOffset;
 }
 
-off_t wxStreamBuffer::Tell() const
+wxFileOffset wxStreamBuffer::Tell() const
 {
-    off_t pos;
+    wxFileOffset pos;
 
-    // only ask the stream for position if we have a real stream and not a
-    // dummy one which we created ourselves, otherwise we'd call
-    // wxStream::OnSysTell() which would always return wxInvalidOffset
-    if ( !m_destroystream )
+    // ask the stream for position if we have a real one
+    if ( m_stream )
     {
         pos = m_stream->OnSysTell();
         if ( pos == wxInvalidOffset )
@@ -643,7 +653,7 @@ off_t wxStreamBuffer::Tell() const
 
 wxStreamBase::wxStreamBase()
 {
-    m_lasterror = wxStream_NOERROR;
+    m_lasterror = wxSTREAM_NO_ERROR;
     m_lastcount = 0;
 }
 
@@ -651,16 +661,36 @@ wxStreamBase::~wxStreamBase()
 {
 }
 
-off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
+size_t wxStreamBase::GetSize() const
+{
+    wxFileOffset length = GetLength();
+    return length == wxInvalidOffset ? 0 : (size_t)length;
+}
+
+wxFileOffset wxStreamBase::OnSysSeek(wxFileOffset WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
 {
     return wxInvalidOffset;
 }
 
-off_t wxStreamBase::OnSysTell() const
+wxFileOffset wxStreamBase::OnSysTell() const
 {
     return wxInvalidOffset;
 }
 
+#if WXWIN_COMPATIBILITY_2_2
+
+wxStreamError wxStreamBase::LastError() const
+{
+    return m_lasterror;
+}
+
+size_t wxStreamBase::StreamSize() const
+{
+    return GetSize();
+}
+
+#endif // WXWIN_COMPATIBILITY_2_2
+
 // ----------------------------------------------------------------------------
 // wxInputStream
 // ----------------------------------------------------------------------------
@@ -677,31 +707,19 @@ wxInputStream::~wxInputStream()
     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
 {
-    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)
@@ -730,7 +748,7 @@ char *wxInputStream::AllocSpaceWBack(size_t needed_size)
     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;
@@ -738,13 +756,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;
 
-    if ( bsize < toget )
+    if ( size < toget )
     {
         // 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;
@@ -773,7 +791,7 @@ size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
     if (!ptrback)
         return 0;
 
-    // Eof() shouldn't return TRUE any longer
+    // Eof() shouldn't return true any longer
     if ( m_lasterror == wxSTREAM_EOF )
         m_lasterror = wxSTREAM_NO_ERROR;
 
@@ -783,13 +801,13 @@ size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 
 bool wxInputStream::Ungetch(char c)
 {
-    return Ungetch(&c, sizeof(char)) != 0;
+    return Ungetch(&c, sizeof(c)) != 0;
 }
 
 char wxInputStream::GetC()
 {
     char c;
-    Read(&c, 1);
+    Read(&c, sizeof(c));
     return c;
 }
 
@@ -811,7 +829,14 @@ wxInputStream& wxInputStream::Read(void *buf, size_t size)
             break;
         }
 
-        read = OnSysRead(buf, size);
+        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
@@ -825,8 +850,8 @@ wxInputStream& wxInputStream::Read(void *buf, size_t size)
 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;
@@ -838,17 +863,21 @@ char wxInputStream::Peek()
 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;
 }
 
-off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
+wxFileOffset wxInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
 {
     // RR: This code is duplicated in wxBufferedInputStream. This is
     // not really a good design, but buffered stream are different
@@ -857,7 +886,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)
-        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
@@ -868,11 +897,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... */
-       
+
     if (m_wback)
     {
         wxLogDebug( wxT("Seeking in stream which has data written back to it.") );
-        
+
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
@@ -882,9 +911,9 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
     return OnSysSeek(pos, mode);
 }
 
-off_t wxInputStream::TellI() const
+wxFileOffset wxInputStream::TellI() const
 {
-    off_t pos = OnSysTell();
+    wxFileOffset pos = OnSysTell();
 
     if (pos != wxInvalidOffset)
         pos -= (m_wbacksize - m_wbackcur);
@@ -913,7 +942,7 @@ size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
 
 void wxOutputStream::PutC(char c)
 {
-    Write(&c, 1);
+    Write(&c, sizeof(c));
 }
 
 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
@@ -928,12 +957,12 @@ wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
     return *this;
 }
 
-off_t wxOutputStream::TellO() const
+wxFileOffset wxOutputStream::TellO() const
 {
     return OnSysTell();
 }
 
-off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
+wxFileOffset wxOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
 {
     return OnSysSeek(pos, mode);
 }
@@ -952,7 +981,7 @@ wxCountingOutputStream::wxCountingOutputStream ()
      m_currentPos = 0;
 }
 
-size_t wxCountingOutputStream::GetSize() const
+wxFileOffset wxCountingOutputStream::GetLength() const
 {
     return m_lastcount;
 }
@@ -967,20 +996,24 @@ size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer),
     return m_currentPos;
 }
 
-off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
+wxFileOffset wxCountingOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 {
+    ssize_t new_pos = (ssize_t)pos;
+
     switch ( mode )
     {
         case wxFromStart:
-            m_currentPos = pos;
+            wxCHECK_MSG( (wxFileOffset)new_pos == pos, wxInvalidOffset, wxT("huge position not supported") );
             break;
 
         case wxFromEnd:
-            m_currentPos = m_lastcount + pos;
+            new_pos = m_lastcount + new_pos;
+            wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_lastcount + pos), wxInvalidOffset, wxT("huge position not supported") );
             break;
 
         case wxFromCurrent:
-            m_currentPos += pos;
+            new_pos = m_currentPos + new_pos;
+            wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_currentPos + pos), wxInvalidOffset, wxT("huge position not supported") );
             break;
 
         default:
@@ -988,13 +1021,15 @@ off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
             return wxInvalidOffset;
     }
 
+    m_currentPos = new_pos;
+
     if (m_currentPos > m_lastcount)
         m_lastcount = m_currentPos;
 
     return m_currentPos;
 }
 
-off_t wxCountingOutputStream::OnSysTell() const
+wxFileOffset wxCountingOutputStream::OnSysTell() const
 {
     return m_currentPos;
 }
@@ -1058,7 +1093,7 @@ wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s,
 
 wxBufferedInputStream::~wxBufferedInputStream()
 {
-    m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
+    m_parent_i_stream->SeekI(-(wxFileOffset)m_i_streambuf->GetBytesLeft(),
                              wxFromCurrent);
 
     delete m_i_streambuf;
@@ -1072,7 +1107,7 @@ char wxBufferedInputStream::Peek()
 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);
@@ -1095,33 +1130,33 @@ wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
     return *this;
 }
 
-off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
+wxFileOffset wxBufferedInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
 {
     // 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.") );
-        
+
         free(m_wback);
         m_wback = NULL;
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
-    
+
     return m_i_streambuf->Seek(pos, mode);
 }
 
-off_t wxBufferedInputStream::TellI() const
+wxFileOffset wxBufferedInputStream::TellI() const
 {
-    off_t pos = m_i_streambuf->Tell();
+    wxFileOffset pos = m_i_streambuf->Tell();
 
     if (pos != wxInvalidOffset)
         pos -= (m_wbacksize - m_wbackcur);
-        
+
     return pos;
 }
 
@@ -1130,12 +1165,12 @@ size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
     return m_parent_i_stream->Read(buffer, bufsize).LastRead();
 }
 
-off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
+wxFileOffset wxBufferedInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
 {
     return m_parent_i_stream->SeekI(seek, mode);
 }
 
-off_t wxBufferedInputStream::OnSysTell() const
+wxFileOffset wxBufferedInputStream::OnSysTell() const
 {
     return m_parent_i_stream->TellI();
 }
@@ -1174,6 +1209,13 @@ wxBufferedOutputStream::~wxBufferedOutputStream()
     delete m_o_streambuf;
 }
 
+bool wxBufferedOutputStream::Close()
+{
+    Sync();
+    return IsOk();
+}
+
+
 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
 {
     m_lastcount = 0;
@@ -1181,13 +1223,13 @@ wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
     return *this;
 }
 
-off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
+wxFileOffset wxBufferedOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
 {
     Sync();
     return m_o_streambuf->Seek(pos, mode);
 }
 
-off_t wxBufferedOutputStream::TellO() const
+wxFileOffset wxBufferedOutputStream::TellO() const
 {
     return m_o_streambuf->Tell();
 }
@@ -1203,19 +1245,19 @@ size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
     return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
 }
 
-off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
+wxFileOffset wxBufferedOutputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
 {
     return m_parent_o_stream->SeekO(seek, mode);
 }
 
-off_t wxBufferedOutputStream::OnSysTell() const
+wxFileOffset wxBufferedOutputStream::OnSysTell() const
 {
     return m_parent_o_stream->TellO();
 }
 
-size_t wxBufferedOutputStream::GetSize() const
+wxFileOffset wxBufferedOutputStream::GetLength() const
 {
-   return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
+   return m_parent_o_stream->GetLength() + m_o_streambuf->GetIntPosition();
 }
 
 void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)