]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/stream.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Store property name and value in wxPropertyGridEvent, keep track of live event instan...
[wxWidgets.git] / src / common / stream.cpp
diff --git a/src/common/stream.cpp b/src/common/stream.cpp
index 16ab8391cbb417e1aac4879eb19bcd83c0d6f15a..1a03caa34604cedf54b1fe45d8e7125af2a9c9fe 100644 (file)
--- a/src/common/stream.cpp
+++ b/src/common/stream.cpp
@@ -1,456 +1,686 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        stream.cpp
+// Name:        src/common/stream.cpp
 // Purpose:     wxStream base classes
 // Author:      Guilhem Lavaux
 // Purpose:     wxStream base classes
 // Author:      Guilhem Lavaux
-// Modified by:
+// Modified by: VZ (23.11.00) to fix realloc()ing new[]ed memory,
+//                            general code review
 // 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
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
-#pragma implementation "stream.h"
-#endif
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-  #pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #endif
 
+#if wxUSE_STREAMS
+
+#include "wx/stream.h"
+
 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP
-  #include "wx/defs.h"
+    #include "wx/log.h"
 #endif
 
 #endif
 
-#if wxUSE_STREAMS
-
 #include <ctype.h>
 #include <ctype.h>
-#include "wx/stream.h"
 #include "wx/datstrm.h"
 #include "wx/datstrm.h"
-#include "wx/objstrm.h"
+#include "wx/textfile.h"
+
+// ----------------------------------------------------------------------------
+// constants
+// ----------------------------------------------------------------------------
+
+// the temporary buffer size used when copying from stream to stream
+#define BUF_TEMP_SIZE 4096
 
 
-#define BUF_TEMP_SIZE 10000
+// ============================================================================
+// implementation
+// ============================================================================
 
 // ----------------------------------------------------------------------------
 // wxStreamBuffer
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxStreamBuffer
 // ----------------------------------------------------------------------------
 
-#define CHECK_ERROR(err) \
-   if (m_stream->m_lasterror == wxStream_NOERROR) \
-     m_stream->m_lasterror = err
+void wxStreamBuffer::SetError(wxStreamError err)
+{
+   if ( m_stream && m_stream->m_lasterror == wxSTREAM_NO_ERROR )
+       m_stream->m_lasterror = err;
+}
+
+void wxStreamBuffer::InitBuffer()
+{
+    m_buffer_start =
+    m_buffer_end =
+    m_buffer_pos = NULL;
+
+    // if we are going to allocate the buffer, we should free it later as well
+    m_destroybuf = true;
+}
+
+void wxStreamBuffer::Init()
+{
+    InitBuffer();
+
+    m_fixed = true;
+}
 
 
-wxStreamBuffer::wxStreamBuffer(wxStreamBase& stream, BufMode mode)
-  : m_buffer_start(NULL), m_buffer_end(NULL), m_buffer_pos(NULL),
-    m_buffer_size(0), m_fixed(TRUE), m_flushable(TRUE), m_stream(&stream),
-    m_mode(mode), m_destroybuf(FALSE), m_destroystream(FALSE)
+void wxStreamBuffer::InitWithStream(wxStreamBase& stream, BufMode mode)
 {
 {
+    Init();
+
+    m_stream = &stream;
+    m_mode = mode;
+
+    m_flushable = true;
 }
 
 wxStreamBuffer::wxStreamBuffer(BufMode mode)
 }
 
 wxStreamBuffer::wxStreamBuffer(BufMode mode)
-  : m_buffer_start(NULL), m_buffer_end(NULL), m_buffer_pos(NULL),
-    m_buffer_size(0), m_fixed(TRUE), m_flushable(FALSE), m_stream(NULL),
-    m_mode(mode), m_destroybuf(FALSE), m_destroystream(TRUE)
 {
 {
-  m_stream = new wxStreamBase();
+    Init();
+
+    m_stream = NULL;
+    m_mode = mode;
+
+    m_flushable = false;
 }
 
 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
 {
 }
 
 wxStreamBuffer::wxStreamBuffer(const wxStreamBuffer& buffer)
 {
-  m_buffer_start = buffer.m_buffer_start;
-  m_buffer_end = buffer.m_buffer_end;
-  m_buffer_pos = buffer.m_buffer_pos;
-  m_buffer_size = buffer.m_buffer_size;
-  m_fixed = buffer.m_fixed;
-  m_flushable = buffer.m_flushable;
-  m_stream = buffer.m_stream;
-  m_mode = buffer.m_mode;
-  m_destroybuf = FALSE;
-  m_destroystream = FALSE;
+    // 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,
+                  wxT("it's a bad idea to copy this buffer") );
+
+    m_buffer_start = buffer.m_buffer_start;
+    m_buffer_end = buffer.m_buffer_end;
+    m_buffer_pos = buffer.m_buffer_pos;
+    m_fixed = buffer.m_fixed;
+    m_flushable = buffer.m_flushable;
+    m_stream = buffer.m_stream;
+    m_mode = buffer.m_mode;
+    m_destroybuf = false;
+}
+
+void wxStreamBuffer::FreeBuffer()
+{
+    if ( m_destroybuf )
+    {
+        free(m_buffer_start);
+        m_buffer_start = NULL;
+    }
 }
 
 wxStreamBuffer::~wxStreamBuffer()
 {
 }
 
 wxStreamBuffer::~wxStreamBuffer()
 {
-  if (m_destroybuf)
-    wxDELETEA(m_buffer_start);
-  if (m_destroystream)
-    delete m_stream;
+    FreeBuffer();
 }
 
 }
 
-void wxStreamBuffer::SetBufferIO(char *buffer_start, char *buffer_end)
+wxInputStream *wxStreamBuffer::GetInputStream() const
 {
 {
-  if (m_destroybuf)
-    wxDELETEA(m_buffer_start);
-  m_buffer_start = buffer_start;
-  m_buffer_end   = buffer_end;
+    return m_mode == write ? NULL : (wxInputStream *)m_stream;
+}
 
 
-  m_buffer_size = m_buffer_end-m_buffer_start;
-  m_destroybuf = FALSE;
-  ResetBuffer();
+wxOutputStream *wxStreamBuffer::GetOutputStream() const
+{
+    return m_mode == read ? NULL : (wxOutputStream *)m_stream;
 }
 
 }
 
-void wxStreamBuffer::SetBufferIO(size_t bufsize)
+void wxStreamBuffer::SetBufferIO(void *buffer_start,
+                                 void *buffer_end,
+                                 bool takeOwnership)
+{
+    SetBufferIO(buffer_start, (char *)buffer_end - (char *)buffer_start,
+                takeOwnership);
+}
+
+void wxStreamBuffer::SetBufferIO(void *start,
+                                 size_t len,
+                                 bool takeOwnership)
 {
 {
-  char *b_start;
+    // start by freeing the old buffer
+    FreeBuffer();
 
 
-  if (m_destroybuf)
-    wxDELETEA(m_buffer_start);
+    m_buffer_start = (char *)start;
+    m_buffer_end   = m_buffer_start + len;
 
 
-  if (!bufsize) {
-    m_buffer_start = (char*)NULL;
-    m_buffer_end = (char*)NULL;
-    m_buffer_pos = (char*)NULL;
-    m_buffer_size = 0;
-    return;
-  }
+    // if we own it, we free it
+    m_destroybuf = takeOwnership;
 
 
-  b_start = new char[bufsize];
-  SetBufferIO(b_start, b_start + bufsize);
-  m_destroybuf = TRUE;
+    ResetBuffer();
+}
+
+void wxStreamBuffer::SetBufferIO(size_t bufsize)
+{
+    if ( bufsize )
+    {
+        // this will free the old buffer and allocate the new one
+        SetBufferIO(malloc(bufsize), bufsize, true /* take ownership */);
+    }
+    else // no buffer size => no buffer
+    {
+        // still free the old one
+        FreeBuffer();
+        InitBuffer();
+    }
 }
 
 void wxStreamBuffer::ResetBuffer()
 {
 }
 
 void wxStreamBuffer::ResetBuffer()
 {
-  m_stream->m_lasterror = wxStream_NOERROR;
-  m_stream->m_lastcount = 0;
-  if (m_mode == read && m_flushable)
+    if ( m_stream )
+    {
+        m_stream->Reset();
+        m_stream->m_lastcount = 0;
+    }
+
+    m_buffer_pos = m_mode == read && m_flushable
+                        ? m_buffer_end
+                        : m_buffer_start;
+}
+
+void wxStreamBuffer::Truncate()
+{
+    size_t new_size = m_buffer_pos - m_buffer_start;
+    if ( m_buffer_pos == m_buffer_end )
+        return;
+
+    if ( !new_size )
+    {
+        FreeBuffer();
+        InitBuffer();
+        return;
+    }
+
+    char *new_start = (char *)realloc(m_buffer_start, new_size);
+    wxCHECK_RET( new_size, wxT("shrinking buffer shouldn't fail") );
+
+    m_buffer_start = new_start;
+    m_buffer_end = m_buffer_start + new_size;
     m_buffer_pos = m_buffer_end;
     m_buffer_pos = m_buffer_end;
-  else
-    m_buffer_pos = m_buffer_start;
 }
 
 }
 
+// fill the buffer with as much data as possible (only for read buffers)
 bool wxStreamBuffer::FillBuffer()
 {
 bool wxStreamBuffer::FillBuffer()
 {
-  size_t count;
+    wxInputStream *inStream = GetInputStream();
+
+    // It's legal to have no stream, so we don't complain about it just return false
+    if ( !inStream )
+        return false;
 
 
-  count = m_stream->OnSysRead(m_buffer_start, m_buffer_size);
-  m_buffer_end = m_buffer_start+count;
-  m_buffer_pos = m_buffer_start;
+    size_t count = inStream->OnSysRead(GetBufferStart(), GetBufferSize());
+    if ( !count )
+        return false;
+
+    m_buffer_end = m_buffer_start + count;
+    m_buffer_pos = m_buffer_start;
 
 
-  if (count == 0)
-    return FALSE;
-  return TRUE;
+    return true;
 }
 
 }
 
+// write the buffer contents to the stream (only for write buffers)
 bool wxStreamBuffer::FlushBuffer()
 {
 bool wxStreamBuffer::FlushBuffer()
 {
-  size_t count, current;
+    wxCHECK_MSG( m_flushable, false, wxT("can't flush this buffer") );
+
+    // FIXME: what is this check for? (VZ)
+    if ( m_buffer_pos == m_buffer_start )
+        return false;
+
+    wxOutputStream *outStream = GetOutputStream();
+
+    wxCHECK_MSG( outStream, false, wxT("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;
+
+    m_buffer_pos = m_buffer_start;
 
 
-  if (m_buffer_pos == m_buffer_start || !m_flushable)
-    return FALSE;
+    return true;
+}
 
 
-  current = m_buffer_pos-m_buffer_start;
-  count = m_stream->OnSysWrite(m_buffer_start, current);
-  if (count != current)
-    return FALSE;
-  m_buffer_pos = m_buffer_start;
+size_t wxStreamBuffer::GetDataLeft()
+{
+    /* Why is this done? RR. */
+    if ( m_buffer_pos == m_buffer_end && m_flushable)
+        FillBuffer();
 
 
-  return TRUE;
+    return GetBytesLeft();
 }
 
 }
 
+// copy up to size bytes from our buffer into the provided one
 void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size)
 {
 void wxStreamBuffer::GetFromBuffer(void *buffer, size_t size)
 {
-  size_t s_toget = m_buffer_end-m_buffer_pos;
+    // don't get more bytes than left in the buffer
+    size_t left = GetBytesLeft();
 
 
-  if (size < s_toget)
-    s_toget = size;
+    if ( size > left )
+        size = left;
 
 
-  memcpy(buffer, m_buffer_pos, s_toget);
-  m_buffer_pos += s_toget;
+    memcpy(buffer, m_buffer_pos, size);
+    m_buffer_pos += size;
 }
 
 }
 
+// copy the contents of the provided buffer into this one
 void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
 {
 void wxStreamBuffer::PutToBuffer(const void *buffer, size_t size)
 {
-  size_t s_toput = m_buffer_end-m_buffer_pos;
-
-  if (s_toput < size && !m_fixed) {
-    if (!m_buffer_start)
-      SetBufferIO(size);
-    else {
-      size_t delta = m_buffer_pos-m_buffer_start;
+    size_t left = GetBytesLeft();
 
 
-      m_buffer_start = (char *)realloc(m_buffer_start, m_buffer_size+size);
-      m_buffer_pos   = m_buffer_start + delta;
-      // I round a bit
-      m_buffer_size += size;
-      m_buffer_end   = m_buffer_start+m_buffer_size;
+    if ( size > left )
+    {
+        if ( m_fixed )
+        {
+            // we can't realloc the buffer, so just copy what we can
+            size = left;
+        }
+        else // !m_fixed
+        {
+            // realloc the buffer to have enough space for the data
+            if ( m_buffer_pos + size > m_buffer_end )
+            {
+                size_t delta = m_buffer_pos - m_buffer_start;
+                size_t new_size = delta + size;
+
+                char *startOld = m_buffer_start;
+                m_buffer_start = (char *)realloc(m_buffer_start, new_size);
+                if ( !m_buffer_start )
+                {
+                    // don't leak memory if realloc() failed
+                    m_buffer_start = startOld;
+
+                    // what else can we do?
+                    return;
+                }
+
+                // adjust the pointers invalidated by realloc()
+                m_buffer_pos = m_buffer_start + delta;
+                m_buffer_end = m_buffer_start + new_size;
+            } // else: the buffer is big enough
+        }
     }
     }
-    s_toput = size;
-  }
-  if (s_toput > size)
-    s_toput = size;
-  memcpy(m_buffer_pos, buffer, s_toput);
-  m_buffer_pos += s_toput;
+
+    memcpy(m_buffer_pos, buffer, size);
+    m_buffer_pos += size;
 }
 
 void wxStreamBuffer::PutChar(char c)
 {
 }
 
 void wxStreamBuffer::PutChar(char c)
 {
-  wxASSERT(m_stream != NULL);
-
-  if (!m_buffer_size) {
-    m_stream->OnSysWrite(&c, 1);
-    return;
-  }
+    wxOutputStream *outStream = GetOutputStream();
 
 
-  if (GetDataLeft() == 0 && !FlushBuffer()) {
-    CHECK_ERROR(wxStream_WRITE_ERR);
-    return;
-  }
+    wxCHECK_RET( outStream, wxT("should have a stream in wxStreamBuffer") );
 
 
-  PutToBuffer(&c, 1);
-  m_stream->m_lastcount = 1;
+    // if we don't have buffer at all, just forward this call to the stream,
+    if ( !HasBuffer() )
+    {
+        outStream->OnSysWrite(&c, sizeof(c));
+    }
+    else
+    {
+        // otherwise check we have enough space left
+        if ( !GetDataLeft() && !FlushBuffer() )
+        {
+            // we don't
+            SetError(wxSTREAM_WRITE_ERROR);
+        }
+        else
+        {
+            PutToBuffer(&c, sizeof(c));
+            m_stream->m_lastcount = 1;
+        }
+    }
 }
 
 char wxStreamBuffer::Peek()
 {
 }
 
 char wxStreamBuffer::Peek()
 {
-  char c;
+    wxCHECK_MSG( m_stream && HasBuffer(), 0,
+                 wxT("should have the stream and the buffer in wxStreamBuffer") );
 
 
-  wxASSERT(m_stream != NULL && m_buffer_size != 0);
-
-  if (!GetDataLeft()) {
-    CHECK_ERROR(wxStream_READ_ERR);
-    return 0;
-  }
+    if ( !GetDataLeft() )
+    {
+        SetError(wxSTREAM_READ_ERROR);
+        return 0;
+    }
 
 
-  GetFromBuffer(&c, 1);
-  m_buffer_pos--;
+    char c;
+    GetFromBuffer(&c, sizeof(c));
+    m_buffer_pos--;
 
 
-  return c;
+    return c;
 }
 
 char wxStreamBuffer::GetChar()
 {
 }
 
 char wxStreamBuffer::GetChar()
 {
-  char c;
+    wxInputStream *inStream = GetInputStream();
 
 
-  wxASSERT(m_stream != NULL);
+    wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") );
 
 
-  if (!m_buffer_size) {
-    m_stream->OnSysRead(&c, 1);
-    return c;
-  }
-
-  if (!GetDataLeft()) {
-    CHECK_ERROR(wxStream_READ_ERR);
-    return 0;
-  }
+    char c;
+    if ( !HasBuffer() )
+    {
+        inStream->OnSysRead(&c, sizeof(c));
+    }
+    else
+    {
+        if ( !GetDataLeft() )
+        {
+            SetError(wxSTREAM_READ_ERROR);
+            c = 0;
+        }
+        else
+        {
+            GetFromBuffer(&c, sizeof(c));
+            m_stream->m_lastcount = 1;
+        }
+    }
 
 
-  GetFromBuffer(&c, 1);
-  
-  m_stream->m_lastcount = 1;
-  return c;
+    return c;
 }
 
 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 {
 }
 
 size_t wxStreamBuffer::Read(void *buffer, size_t size)
 {
-  wxASSERT(m_stream != NULL);
+    wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be used") );
 
 
-  if (m_mode == write)
-    return 0;
+    /* Clear buffer first */
+    memset(buffer, 0x00, size);
 
 
-  // ------------------
-  // Buffering disabled
-  // ------------------
+    // lasterror is reset before all new IO calls
+    if ( m_stream )
+        m_stream->Reset();
 
 
-  m_stream->m_lasterror = wxStream_NOERROR;
-  if (!m_buffer_size)
-    return (m_stream->m_lastcount += m_stream->OnSysRead(buffer, size));
-
-  // -----------------
-  // Buffering enabled
-  // -----------------
-  size_t buf_left, orig_size = size;
+    size_t readBytes;
+    if ( !HasBuffer() )
+    {
+        wxInputStream *inStream = GetInputStream();
 
 
-  while (size > 0) {
-    buf_left = GetDataLeft(); 
+        wxCHECK_MSG( inStream, 0, wxT("should have a stream in wxStreamBuffer") );
 
 
-    // First case: the requested buffer is larger than the stream buffer,
-    //             we split it.
-    if (size > buf_left) {
-      GetFromBuffer(buffer, buf_left);
-      size  -= buf_left;
-      buffer = (char *)buffer + buf_left; // ANSI C++ violation.
+        readBytes = inStream->OnSysRead(buffer, size);
+    }
+    else // we have a buffer, use it
+    {
+        size_t orig_size = size;
+
+        while ( size > 0 )
+        {
+            size_t left = GetDataLeft();
+
+            // if the requested number of bytes if greater than the buffer
+            // size, read data in chunks
+            if ( size > left )
+            {
+                GetFromBuffer(buffer, left);
+                size -= left;
+                buffer = (char *)buffer + left;
+
+                if ( !FillBuffer() )
+                {
+                    SetError(wxSTREAM_EOF);
+                    break;
+                }
+            }
+            else // otherwise just do it in one gulp
+            {
+                GetFromBuffer(buffer, size);
+                size = 0;
+            }
+        }
+
+        readBytes = orig_size - size;
+    }
 
 
-      if (!FillBuffer()) {
-        CHECK_ERROR(wxStream_EOF);
-        return (m_stream->m_lastcount = orig_size-size);
-      }
-    } else {
+    if ( m_stream )
+        m_stream->m_lastcount = readBytes;
 
 
-      // Second case: we just copy from the stream buffer.
-      GetFromBuffer(buffer, size);
-      break;
-    }
-  }
-  return (m_stream->m_lastcount += orig_size);
+    return readBytes;
 }
 
 }
 
-size_t wxStreamBuffer::Read(wxStreamBuffer *s_buf)
+// this should really be called "Copy()"
+size_t wxStreamBuffer::Read(wxStreamBuffer *dbuf)
 {
 {
-  char buf[BUF_TEMP_SIZE];
-  size_t s = 0, bytes_read = BUF_TEMP_SIZE;
+    wxCHECK_MSG( m_mode != write, 0, wxT("can't read from this buffer") );
 
 
-  if (m_mode == write)
-    return 0;
+    char buf[BUF_TEMP_SIZE];
+    size_t nRead,
+           total = 0;
 
 
-  while (bytes_read != 0) {
-    bytes_read = Read(buf, bytes_read);
-    bytes_read = s_buf->Write(buf, bytes_read);
-    s += bytes_read;
-  }
-  return s;
+    do
+    {
+        nRead = Read(buf, WXSIZEOF(buf));
+        if ( nRead )
+        {
+            nRead = dbuf->Write(buf, nRead);
+            total += nRead;
+        }
+    }
+    while ( nRead );
+
+    return total;
 }
 
 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 {
 }
 
 size_t wxStreamBuffer::Write(const void *buffer, size_t size)
 {
-  wxASSERT(m_stream != NULL);
-
-  if (m_mode == read)
-    return 0;
+    wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be send") );
 
 
-  // ------------------
-  // Buffering disabled
-  // ------------------
-
-  m_stream->m_lasterror = wxStream_NOERROR;
-  if (!m_buffer_size && m_fixed)
-    return (m_stream->m_lastcount = m_stream->OnSysWrite(buffer, size));
-
-  // ------------------
-  // Buffering enabled
-  // ------------------
-
-  size_t buf_left, orig_size = size;
-
-  while (size > 0) {
-    buf_left = m_buffer_end - m_buffer_pos;
+    if (m_stream)
+    {
+        // lasterror is reset before all new IO calls
+        m_stream->Reset();
+    }
 
 
-    // First case: the buffer to write is larger than the stream buffer,
-    //             we split it
-    // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream),
-    // we always go to the second case.
-    if (size > buf_left && m_fixed) {
-      PutToBuffer(buffer, buf_left);
-      size -= buf_left;
-      buffer = (char *)buffer + buf_left; // ANSI C++ violation.
+    size_t ret;
 
 
-      if (!FlushBuffer()) {
-       CHECK_ERROR(wxStream_WRITE_ERR);
-        return (m_stream->m_lastcount = orig_size-size);
-      }
+    if ( !HasBuffer() && m_fixed )
+    {
+        wxOutputStream *outStream = GetOutputStream();
 
 
-      m_buffer_pos = m_buffer_start;
+        wxCHECK_MSG( outStream, 0, wxT("should have a stream in wxStreamBuffer") );
 
 
-    } else {
+        // no buffer, just forward the call to the stream
+        ret = outStream->OnSysWrite(buffer, size);
+    }
+    else // we [may] have a buffer, use it
+    {
+        size_t orig_size = size;
+
+        while ( size > 0 )
+        {
+            size_t left = GetBytesLeft();
+
+            // if the buffer is too large to fit in the stream buffer, split
+            // it in smaller parts
+            //
+            // NB: If stream buffer isn't fixed (as for wxMemoryOutputStream),
+            //     we always go to the second case.
+            //
+            // 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);
+                size -= left;
+                buffer = (char *)buffer + left;
+
+                if ( !FlushBuffer() )
+                {
+                    SetError(wxSTREAM_WRITE_ERROR);
+
+                    break;
+                }
+
+                m_buffer_pos = m_buffer_start;
+            }
+            else // we can do it in one gulp
+            {
+                PutToBuffer(buffer, size);
+                size = 0;
+            }
+        }
+
+        ret = orig_size - size;
+    }
 
 
-      // Second case: just copy it in the stream buffer.
-      PutToBuffer(buffer, size);
-      break;
+    if (m_stream)
+    {
+        // i am not entirely sure what we do this for
+        m_stream->m_lastcount = ret;
     }
     }
-  }
-  return (m_stream->m_lastcount = orig_size);
+
+    return ret;
 }
 
 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
 {
 }
 
 size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf)
 {
-  char buf[BUF_TEMP_SIZE];
-  size_t s = 0, bytes_count = BUF_TEMP_SIZE, b_count2;
-  wxInputStream *in_stream;
+    wxCHECK_MSG( m_mode != read, 0, wxT("can't write to this buffer") );
+    wxCHECK_MSG( sbuf->m_mode != write, 0, wxT("can't read from that buffer") );
 
 
-  if (m_mode == read)
-    return 0;
+    char buf[BUF_TEMP_SIZE];
+    size_t nWrite,
+           total = 0;
 
 
-  in_stream = (wxInputStream *)sbuf->Stream();
+    do
+    {
+        size_t nRead = sbuf->Read(buf, WXSIZEOF(buf));
+        if ( nRead )
+        {
+            nWrite = Write(buf, nRead);
+            if ( nWrite < nRead )
+            {
+                // put back data we couldn't copy
+                wxInputStream *in_stream = (wxInputStream *)sbuf->GetStream();
+
+                in_stream->Ungetch(buf + nWrite, nRead - nWrite);
+            }
+
+            total += nWrite;
+        }
+        else
+        {
+            nWrite = 0;
+        }
+    }
+    while ( nWrite == WXSIZEOF(buf) );
 
 
-  while (bytes_count == BUF_TEMP_SIZE) {
-    b_count2 = sbuf->Read(buf, bytes_count);
-    bytes_count = Write(buf, b_count2);
-    if (b_count2 > bytes_count)
-      in_stream->Ungetch(buf+bytes_count, b_count2-bytes_count);
-    s += bytes_count;
-  }
-  return s;
+    return total;
 }
 
 }
 
-off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
+wxFileOffset wxStreamBuffer::Seek(wxFileOffset pos, wxSeekMode mode)
 {
 {
-  off_t ret_off, diff, last_access;
+    wxFileOffset ret_off, diff;
 
 
-  last_access = GetLastAccess();
+    wxFileOffset last_access = GetLastAccess();
 
 
-  if (!m_flushable) {
-    switch (mode) {
-      case wxFromStart:   diff = pos;                     break;
-      case wxFromCurrent: diff = pos + GetIntPosition();  break;
-      case wxFromEnd:     diff = pos + last_access;       break;
-      default: return wxInvalidOffset;
+    if ( !m_flushable )
+    {
+        switch (mode)
+        {
+            case wxFromStart:
+                diff = pos;
+                break;
+
+            case wxFromCurrent:
+                diff = pos + GetIntPosition();
+                break;
+
+            case wxFromEnd:
+                diff = pos + last_access;
+                break;
+
+            default:
+                wxFAIL_MSG( wxT("invalid seek mode") );
+
+                return wxInvalidOffset;
+        }
+        if (diff < 0 || diff > last_access)
+            return wxInvalidOffset;
+        size_t int_diff = wx_truncate_cast(size_t, diff);
+        wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
+        SetIntPosition(int_diff);
+        return diff;
     }
     }
-    if (diff < 0 || diff > last_access)
-      return wxInvalidOffset;
-    SetIntPosition(diff);
-    return diff;
-  }
 
 
-  switch (mode) {
-  case wxFromStart: {
-    // We'll try to compute an internal position later ...
-    ret_off = m_stream->OnSysSeek(pos, wxFromStart);
-    ResetBuffer();
-    return ret_off;
-  }
-  case wxFromCurrent: {
-    diff = pos + GetIntPosition();
-
-    if ( (diff > last_access) || (diff < 0) ) {
-      // We must take into account the fact that we have read something
-      // previously.
-      ret_off = m_stream->OnSysSeek(diff-last_access, wxFromCurrent);
-      ResetBuffer();
-      return ret_off;
-    } else {
-      SetIntPosition(diff);
-      return pos;
-    }
-  }
-  case wxFromEnd:
-    // Hard to compute: always seek to the requested position.
-    ret_off = m_stream->OnSysSeek(pos, wxFromEnd);
-    ResetBuffer();
-    return ret_off;
-  }
-  return wxInvalidOffset;
+    switch ( mode )
+    {
+        case wxFromStart:
+            // We'll try to compute an internal position later ...
+            ret_off = m_stream->OnSysSeek(pos, wxFromStart);
+            ResetBuffer();
+            return ret_off;
+
+        case wxFromCurrent:
+            diff = pos + GetIntPosition();
+
+            if ( (diff > last_access) || (diff < 0) )
+            {
+                // We must take into account the fact that we have read
+                // something previously.
+                ret_off = m_stream->OnSysSeek(diff-last_access, wxFromCurrent);
+                ResetBuffer();
+                return ret_off;
+            }
+            else
+            {
+                size_t int_diff = wx_truncate_cast(size_t, diff);
+                wxCHECK_MSG( (wxFileOffset)int_diff == diff, wxInvalidOffset, wxT("huge file not supported") );
+                SetIntPosition(int_diff);
+                return diff;
+            }
+
+        case wxFromEnd:
+            // Hard to compute: always seek to the requested position.
+            ret_off = m_stream->OnSysSeek(pos, wxFromEnd);
+            ResetBuffer();
+            return ret_off;
+    }
+
+    return wxInvalidOffset;
 }
 
 }
 
-off_t wxStreamBuffer::Tell() const
+wxFileOffset wxStreamBuffer::Tell() const
 {
 {
-    off_t pos = m_stream->OnSysTell();
-    if (pos == wxInvalidOffset)
-        return wxInvalidOffset;
+    wxFileOffset 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();
-       
-    if (m_mode == read && m_flushable)
+
+    if ( m_mode == read && m_flushable )
         pos -= GetLastAccess();
         pos -= GetLastAccess();
-    
-    return pos;
-}
 
 
-size_t wxStreamBuffer::GetDataLeft()
-{
-    /* Why is this done? RR. */
-    if (m_buffer_end == m_buffer_pos && m_flushable)
-        FillBuffer();
-       
-    return m_buffer_end-m_buffer_pos;
+    return pos;
 }
 
 // ----------------------------------------------------------------------------
 // wxStreamBase
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // wxStreamBase
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject)
+
 wxStreamBase::wxStreamBase()
 {
 wxStreamBase::wxStreamBase()
 {
-    m_lasterror = wxStream_NOERROR;
+    m_lasterror = wxSTREAM_NO_ERROR;
     m_lastcount = 0;
 }
 
     m_lastcount = 0;
 }
 
@@ -458,22 +688,24 @@ wxStreamBase::~wxStreamBase()
 {
 }
 
 {
 }
 
-size_t wxStreamBase::OnSysRead(void *WXUNUSED(buffer), size_t WXUNUSED(size))
+size_t wxStreamBase::GetSize() const
 {
 {
-    return 0;
-}
+    wxFileOffset length = GetLength();
+    if ( length == (wxFileOffset)wxInvalidOffset )
+        return 0;
 
 
-size_t wxStreamBase::OnSysWrite(const void *WXUNUSED(buffer), size_t WXUNUSED(bufsize))
-{
-    return 0;
+    const size_t len = wx_truncate_cast(size_t, length);
+    wxASSERT_MSG( len == length + size_t(0), wxT("large files not supported") );
+
+    return len;
 }
 
 }
 
-off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
+wxFileOffset wxStreamBase::OnSysSeek(wxFileOffset WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
 {
     return wxInvalidOffset;
 }
 
 {
     return wxInvalidOffset;
 }
 
-off_t wxStreamBase::OnSysTell() const
+wxFileOffset wxStreamBase::OnSysTell() const
 {
     return wxInvalidOffset;
 }
 {
     return wxInvalidOffset;
 }
@@ -482,154 +714,266 @@ off_t wxStreamBase::OnSysTell() const
 // wxInputStream
 // ----------------------------------------------------------------------------
 
 // wxInputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase)
+
 wxInputStream::wxInputStream()
 wxInputStream::wxInputStream()
-  : wxStreamBase(),
-    m_wback(NULL), m_wbacksize(0), m_wbackcur(0)
 {
 {
+    m_wback = NULL;
+    m_wbacksize =
+    m_wbackcur = 0;
 }
 
 wxInputStream::~wxInputStream()
 {
 }
 
 wxInputStream::~wxInputStream()
 {
-  if (m_wback)
     free(m_wback);
 }
 
     free(m_wback);
 }
 
+bool wxInputStream::CanRead() const
+{
+    // 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
+{
+    // 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)
 {
-    /* get number of bytes left from previous wback buffer */
+    // get number of bytes left from previous wback buffer
     size_t toget = m_wbacksize - m_wbackcur;
 
     size_t toget = m_wbacksize - m_wbackcur;
 
-    /* allocate a buffer large enough to hold prev + new data */
-    char *temp_b = (char *) malloc(needed_size + toget);
+    // allocate a buffer large enough to hold prev + new data
+    char *temp_b = (char *)malloc(needed_size + toget);
 
     if (!temp_b)
         return NULL;
 
 
     if (!temp_b)
         return NULL;
 
-    /* copy previous data (and free old buffer) if needed */
+    // copy previous data (and free old buffer) if needed
     if (m_wback)
     {
         memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
         free(m_wback);
     }
 
     if (m_wback)
     {
         memmove(temp_b + needed_size, m_wback + m_wbackcur, toget);
         free(m_wback);
     }
 
-    /* done */
+    // done
     m_wback = temp_b;
     m_wbackcur = 0;
     m_wbacksize = needed_size + toget;
 
     m_wback = temp_b;
     m_wbackcur = 0;
     m_wbacksize = needed_size + toget;
 
-    return (char *) m_wback;
+    return m_wback;
 }
 
 }
 
-size_t wxInputStream::GetWBack(char *buf, size_t bsize)
+size_t wxInputStream::GetWBack(void *buf, size_t size)
 {
 {
-    size_t s_toget = m_wbacksize-m_wbackcur;
+    wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used") );
+
+    /* Clear buffer first */
+    memset(buf, 0x00, size);
 
     if (!m_wback)
         return 0;
 
 
     if (!m_wback)
         return 0;
 
-    if (bsize < s_toget)
-       s_toget = bsize;
+    // how many bytes do we have in the buffer?
+    size_t toget = m_wbacksize - m_wbackcur;
+
+    if ( size < toget )
+    {
+        // we won't read everything
+        toget = size;
+    }
 
 
-    memcpy(buf, (m_wback+m_wbackcur), s_toget);
+    // copy the data from the cache
+    memcpy(buf, m_wback + m_wbackcur, toget);
 
 
-    m_wbackcur += s_toget;
-    if (m_wbackcur == m_wbacksize) 
+    m_wbackcur += toget;
+    if ( m_wbackcur == m_wbacksize )
     {
     {
+        // TODO: should we really free it here all the time? maybe keep it?
         free(m_wback);
         free(m_wback);
-        m_wback = (char *)NULL;
+        m_wback = NULL;
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
-    
-    return s_toget;
+
+    // return the number of bytes copied
+    return toget;
 }
 
 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 {
 }
 
 size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
 {
+    wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used in Ungetch()") );
+
+    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)
 {
-    char * ptrback = AllocSpaceWBack(1);
-    if (!ptrback)
-        return FALSE;
-
-    *ptrback = c;
-    return TRUE;
+    return Ungetch(&c, sizeof(c)) != 0;
 }
 
 }
 
-char wxInputStream::GetC()
+int wxInputStream::GetC()
 {
 {
-    char c;
-    Read(&c, 1);
-    return c;
+    unsigned char c;
+    Read(&c, sizeof(c));
+    return LastRead() ? c : wxEOF;
 }
 
 }
 
-wxInputStream& wxInputStream::Read(void *buffer, size_t size)
+wxInputStream& wxInputStream::Read(void *buf, size_t size)
 {
 {
-    char *buf = (char *)buffer;
+    wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be read") );
+
+    char *p = (char *)buf;
+    m_lastcount = 0;
 
 
-    size_t retsize = GetWBack(buf, size);
-    if (retsize == size) 
+    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  += 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;
     }
-    
+
     return 0;
 }
 
 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 {
     return 0;
 }
 
 wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
 {
-    char buf[BUF_TEMP_SIZE]; 
-    size_t bytes_read = BUF_TEMP_SIZE;
+    size_t lastcount = 0;
+    char buf[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;
+
+        lastcount += bytes_read;
     }
     }
+
+    m_lastcount = lastcount;
+
     return *this;
 }
 
     return *this;
 }
 
-off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
+wxFileOffset wxInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
 {
 {
-    /* Should be check and improve, just to remove a slight bug !
-       I don't know whether it should be put as well in wxFileInputStream::OnSysSeek ? */
-    if (m_lasterror==wxSTREAM_EOF) 
-        m_lasterror=wxSTREAM_NOERROR;
+    // RR: This code is duplicated in wxBufferedInputStream. This is
+    // not really a good design, but buffered stream are different
+    // from all others in that they handle two stream-related objects:
+    // the stream buffer and parent stream.
 
 
-    /* A call to SeekI() will automatically invalidate any previous call
-       to Ungetch(), otherwise it would be possible to SeekI() to one
+    // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek
+    if (m_lasterror==wxSTREAM_EOF)
+        m_lasterror=wxSTREAM_NO_ERROR;
+
+    // avoid unnecessary seek operations (optimization)
+    wxFileOffset currentPos = TellI(), size = GetLength();
+    if ((mode == wxFromStart && currentPos == pos) ||
+        (mode == wxFromCurrent && pos == 0) ||
+        (mode == wxFromEnd && size != wxInvalidOffset && currentPos == size-pos))
+        return currentPos;
+
+    if (!IsSeekable() && mode == wxFromCurrent && pos > 0)
+    {
+        // rather than seeking, we can just read data and discard it;
+        // this allows to forward-seek also non-seekable streams!
+        char buf[BUF_TEMP_SIZE];
+        size_t bytes_read;
+
+        // read chunks of BUF_TEMP_SIZE bytes until we reach the new position
+        for ( ; pos >= BUF_TEMP_SIZE; pos -= bytes_read)
+        {
+            bytes_read = Read(buf, WXSIZEOF(buf)).LastRead();
+            if ( m_lasterror != wxSTREAM_NO_ERROR )
+                return wxInvalidOffset;
+
+            wxASSERT(bytes_read == WXSIZEOF(buf));
+        }
+
+        // read the last 'pos' bytes
+        bytes_read = Read(buf, (size_t)pos).LastRead();
+        if ( m_lasterror != wxSTREAM_NO_ERROR )
+            return wxInvalidOffset;
+
+        wxASSERT(bytes_read == (size_t)pos);
+
+        // we should now have seeked to the right position...
+        return TellI();
+    }
+
+    /* RR: A call to SeekI() will automatically invalidate any previous
+       call to Ungetch(), otherwise it would be possible to SeekI() to
        one position, unread some bytes there, SeekI() to another position
        one position, unread some bytes there, SeekI() to another position
-       and the data would be corrupted. */
-    if (m_wback) 
+       and the data would be corrupted.
+
+       GRG: Could add code here to try to navigate within the wback
+       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);
         free(m_wback);
-        m_wback = (char*) NULL;
+        m_wback = NULL;
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
         m_wbacksize = 0;
         m_wbackcur = 0;
     }
@@ -637,30 +981,24 @@ off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
     return OnSysSeek(pos, mode);
 }
 
     return OnSysSeek(pos, mode);
 }
 
-off_t wxInputStream::TellI() const
+wxFileOffset wxInputStream::TellI() const
 {
 {
-    return OnSysTell();
-}
+    wxFileOffset pos = OnSysTell();
 
 
-// --------------------
-// Overloaded operators
-// --------------------
+    if (pos != wxInvalidOffset)
+        pos -= (m_wbacksize - m_wbackcur);
 
 
-#if wxUSE_SERIAL
-wxInputStream& wxInputStream::operator>>(wxObject *& obj)
-{
-    wxObjectInputStream obj_s(*this);
-    obj = obj_s.LoadObject();
-    return *this;
+    return pos;
 }
 }
-#endif
 
 
 // ----------------------------------------------------------------------------
 // wxOutputStream
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxOutputStream
 // ----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase)
+
 wxOutputStream::wxOutputStream()
 wxOutputStream::wxOutputStream()
-  : wxStreamBase()
 {
 }
 
 {
 }
 
@@ -668,9 +1006,15 @@ wxOutputStream::~wxOutputStream()
 {
 }
 
 {
 }
 
+size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer),
+                                  size_t WXUNUSED(bufsize))
+{
+    return 0;
+}
+
 void wxOutputStream::PutC(char c)
 {
 void wxOutputStream::PutC(char c)
 {
-    Write((void *) &c, 1);
+    Write(&c, sizeof(c));
 }
 
 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
 }
 
 wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size)
@@ -685,12 +1029,12 @@ wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in)
     return *this;
 }
 
     return *this;
 }
 
-off_t wxOutputStream::TellO() const
+wxFileOffset wxOutputStream::TellO() const
 {
     return OnSysTell();
 }
 
 {
     return OnSysTell();
 }
 
-off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
+wxFileOffset wxOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
 {
     return OnSysSeek(pos, mode);
 }
 {
     return OnSysSeek(pos, mode);
 }
@@ -699,107 +1043,235 @@ void wxOutputStream::Sync()
 {
 }
 
 {
 }
 
-#if wxUSE_SERIAL
-wxOutputStream& wxOutputStream::operator<<(wxObject& obj)
-{
-    wxObjectOutputStream obj_s(*this);
-    obj_s.SaveObject(obj);
-    return *this;
-}
-#endif
 
 // ----------------------------------------------------------------------------
 // wxCountingOutputStream
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxCountingOutputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream)
+
 wxCountingOutputStream::wxCountingOutputStream ()
 wxCountingOutputStream::wxCountingOutputStream ()
-  : wxOutputStream()
 {
      m_currentPos = 0;
 }
 
 {
      m_currentPos = 0;
 }
 
-size_t wxCountingOutputStream::GetSize() const
+wxFileOffset wxCountingOutputStream::GetLength() const
 {
     return m_lastcount;
 }
 
 {
     return m_lastcount;
 }
 
-size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer), size_t size)
+size_t wxCountingOutputStream::OnSysWrite(const void *WXUNUSED(buffer),
+                                          size_t size)
 {
     m_currentPos += size;
 {
     m_currentPos += size;
-    if (m_currentPos > m_lastcount) m_lastcount = m_currentPos;
+    if (m_currentPos > m_lastcount)
+        m_lastcount = m_currentPos;
+
     return m_currentPos;
 }
 
     return m_currentPos;
 }
 
-off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
+wxFileOffset wxCountingOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
 {
 {
-    if (mode == wxFromStart)
-        m_currentPos = pos;
-    if (mode == wxFromEnd)
-        m_currentPos = m_lastcount + pos;
-    else
-        m_currentPos += pos;
-    
-    if (m_currentPos > m_lastcount) m_lastcount = m_currentPos;
-  
+    ssize_t new_pos = wx_truncate_cast(ssize_t, pos);
+
+    switch ( mode )
+    {
+        case wxFromStart:
+            wxCHECK_MSG( (wxFileOffset)new_pos == pos, wxInvalidOffset, wxT("huge position not supported") );
+            break;
+
+        case wxFromEnd:
+            new_pos = m_lastcount + new_pos;
+            wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_lastcount + pos), wxInvalidOffset, wxT("huge position not supported") );
+            break;
+
+        case wxFromCurrent:
+            new_pos = m_currentPos + new_pos;
+            wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_currentPos + pos), wxInvalidOffset, wxT("huge position not supported") );
+            break;
+
+        default:
+            wxFAIL_MSG( wxT("invalid seek mode") );
+            return wxInvalidOffset;
+    }
+
+    m_currentPos = new_pos;
+
+    if (m_currentPos > m_lastcount)
+        m_lastcount = m_currentPos;
+
     return m_currentPos;
 }
 
     return m_currentPos;
 }
 
-off_t wxCountingOutputStream::OnSysTell() const
+wxFileOffset wxCountingOutputStream::OnSysTell() const
 {
     return m_currentPos;
 }
 {
     return m_currentPos;
 }
-  
+
 // ----------------------------------------------------------------------------
 // wxFilterInputStream
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxFilterInputStream
 // ----------------------------------------------------------------------------
 
+IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream)
+
 wxFilterInputStream::wxFilterInputStream()
 wxFilterInputStream::wxFilterInputStream()
-  : wxInputStream()
+ :  m_parent_i_stream(NULL),
+    m_owns(false)
 {
 }
 
 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
 {
 }
 
 wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
-  : wxInputStream()
+ :  m_parent_i_stream(&stream),
+    m_owns(false)
+{
+}
+
+wxFilterInputStream::wxFilterInputStream(wxInputStream *stream)
+ :  m_parent_i_stream(stream),
+    m_owns(true)
 {
 {
-    m_parent_i_stream = &stream;
 }
 
 wxFilterInputStream::~wxFilterInputStream()
 {
 }
 
 wxFilterInputStream::~wxFilterInputStream()
 {
+    if (m_owns)
+        delete m_parent_i_stream;
 }
 
 // ----------------------------------------------------------------------------
 // wxFilterOutputStream
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
 // wxFilterOutputStream
 // ----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxFilterOutputStream, wxOutputStream)
+
 wxFilterOutputStream::wxFilterOutputStream()
 wxFilterOutputStream::wxFilterOutputStream()
-  : wxOutputStream()
+ :  m_parent_o_stream(NULL),
+    m_owns(false)
 {
 }
 
 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
 {
 }
 
 wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
-  : wxOutputStream()
+ :  m_parent_o_stream(&stream),
+    m_owns(false)
 {
 {
-    m_parent_o_stream = &stream;
+}
+
+wxFilterOutputStream::wxFilterOutputStream(wxOutputStream *stream)
+ :  m_parent_o_stream(stream),
+    m_owns(true)
+{
+}
+
+bool wxFilterOutputStream::Close()
+{
+    if (m_parent_o_stream && m_owns)
+        return m_parent_o_stream->Close();
+    else
+        return true;
 }
 
 wxFilterOutputStream::~wxFilterOutputStream()
 {
 }
 
 wxFilterOutputStream::~wxFilterOutputStream()
 {
+    if (m_owns)
+        delete m_parent_o_stream;
+}
+
+// ----------------------------------------------------------------------------
+// wxFilterClassFactoryBase
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactoryBase, wxObject)
+
+wxString wxFilterClassFactoryBase::PopExtension(const wxString& location) const
+{
+    return location.substr(0, FindExtension(location));
+}
+
+wxString::size_type wxFilterClassFactoryBase::FindExtension(
+        const wxString& location) const
+{
+    for (const wxChar *const *p = GetProtocols(wxSTREAM_FILEEXT); *p; p++)
+    {
+        if ( location.EndsWith(*p) )
+            return location.length() - wxStrlen(*p);
+    }
+
+    return wxString::npos;
+}
+
+bool wxFilterClassFactoryBase::CanHandle(const wxString& protocol,
+                                         wxStreamProtocolType type) const
+{
+    if (type == wxSTREAM_FILEEXT)
+        return FindExtension(protocol) != wxString::npos;
+    else
+        for (const wxChar *const *p = GetProtocols(type); *p; p++)
+            if (protocol == *p)
+                return true;
+
+    return false;
+}
+
+// ----------------------------------------------------------------------------
+// wxFilterClassFactory
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxFilterClassFactory, wxFilterClassFactoryBase)
+
+wxFilterClassFactory *wxFilterClassFactory::sm_first = NULL;
+
+void wxFilterClassFactory::Remove()
+{
+    if (m_next != this)
+    {
+        wxFilterClassFactory **pp = &sm_first;
+
+        while (*pp != this)
+            pp = &(*pp)->m_next;
+
+        *pp = m_next;
+
+        m_next = this;
+    }
 }
 
 // ----------------------------------------------------------------------------
 // wxBufferedInputStream
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
 // wxBufferedInputStream
 // ----------------------------------------------------------------------------
-wxBufferedInputStream::wxBufferedInputStream(wxInputStream& s)
-  : wxFilterInputStream(s)
+
+namespace
+{
+
+// helper function used for initializing the buffer used by
+// wxBufferedInput/OutputStream: it simply returns the provided buffer if it's
+// not NULL or creates a buffer of the given size otherwise
+template <typename T>
+wxStreamBuffer *
+CreateBufferIfNeeded(T& stream, wxStreamBuffer *buffer, size_t bufsize = 1024)
+{
+    return buffer ? buffer : new wxStreamBuffer(bufsize, stream);
+}
+
+} // anonymous namespace
+
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
+                                             wxStreamBuffer *buffer)
+                     : wxFilterInputStream(stream)
+{
+    m_i_streambuf = CreateBufferIfNeeded(*this, buffer);
+}
+
+wxBufferedInputStream::wxBufferedInputStream(wxInputStream& stream,
+                                             size_t bufsize)
+                     : wxFilterInputStream(stream)
 {
 {
-    m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read);
-    m_i_streambuf->SetBufferIO(1024);
+    m_i_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize);
 }
 
 wxBufferedInputStream::~wxBufferedInputStream()
 {
 }
 
 wxBufferedInputStream::~wxBufferedInputStream()
 {
-    off_t unused_bytes=m_i_streambuf->GetBufferPos()-m_i_streambuf->GetBufferEnd();
-    m_parent_i_stream->SeekI(unused_bytes,wxFromCurrent);
+    m_parent_i_stream->SeekI(-(wxFileOffset)m_i_streambuf->GetBytesLeft(),
+                             wxFromCurrent);
 
     delete m_i_streambuf;
 }
 
     delete m_i_streambuf;
 }
@@ -809,34 +1281,63 @@ char wxBufferedInputStream::Peek()
     return m_i_streambuf->Peek();
 }
 
     return m_i_streambuf->Peek();
 }
 
-wxInputStream& wxBufferedInputStream::Read(void *buffer, size_t size)
+wxInputStream& wxBufferedInputStream::Read(void *buf, size_t size)
 {
 {
-    size_t retsize;
-    char *buf = (char *)buffer;
+    // reset the error flag
+    Reset();
 
 
-    retsize = GetWBack(buf, size);
-    m_lastcount = retsize;
-    if (retsize == size) 
+    // first read from the already cached data
+    m_lastcount = GetWBack(buf, size);
+
+    // do we have to read anything more?
+    if ( m_lastcount < size )
     {
     {
-        m_lasterror = wxStream_NOERROR;
-        return *this;
-    }
-    size -= retsize;
-    buf  += retsize;
+        size -= m_lastcount;
+        buf = (char *)buf + m_lastcount;
+
+        // the call to wxStreamBuffer::Read() below may reset our m_lastcount
+        // (but it also may not do it if the buffer is associated to another
+        // existing stream and wasn't created by us), so save it
+        size_t countOld = m_lastcount;
 
 
-    m_i_streambuf->Read(buf, size);
+        // the new count of the bytes read is the count of bytes read this time
+        m_lastcount = m_i_streambuf->Read(buf, size);
+
+        // plus those we had read before
+        m_lastcount += countOld;
+    }
 
     return *this;
 }
 
 
     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)
+        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);
 }
 
     return m_i_streambuf->Seek(pos, mode);
 }
 
-off_t wxBufferedInputStream::TellI() const
+wxFileOffset wxBufferedInputStream::TellI() const
 {
 {
-    return m_i_streambuf->Tell();
+    wxFileOffset pos = m_i_streambuf->Tell();
+
+    if (pos != wxInvalidOffset)
+        pos -= (m_wbacksize - m_wbackcur);
+
+    return pos;
 }
 
 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
 }
 
 size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
@@ -844,26 +1345,40 @@ size_t wxBufferedInputStream::OnSysRead(void *buffer, size_t bufsize)
     return m_parent_i_stream->Read(buffer, bufsize).LastRead();
 }
 
     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);
 }
 
 {
     return m_parent_i_stream->SeekI(seek, mode);
 }
 
-off_t wxBufferedInputStream::OnSysTell() const
+wxFileOffset wxBufferedInputStream::OnSysTell() const
 {
     return m_parent_i_stream->TellI();
 }
 
 {
     return m_parent_i_stream->TellI();
 }
 
+void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer)
+{
+    wxCHECK_RET( buffer, wxT("wxBufferedInputStream needs buffer") );
+
+    delete m_i_streambuf;
+    m_i_streambuf = buffer;
+}
 
 // ----------------------------------------------------------------------------
 // wxBufferedOutputStream
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxBufferedOutputStream
 // ----------------------------------------------------------------------------
 
-wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& s)
-  : wxFilterOutputStream(s)
+wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream,
+                                               wxStreamBuffer *buffer)
+                      : wxFilterOutputStream(stream)
+{
+    m_o_streambuf = CreateBufferIfNeeded(*this, buffer);
+}
+
+wxBufferedOutputStream::wxBufferedOutputStream(wxOutputStream& stream,
+                                               size_t bufsize)
+                      : wxFilterOutputStream(stream)
 {
 {
-    m_o_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::write);
-    m_o_streambuf->SetBufferIO(1024);
+    m_o_streambuf = CreateBufferIfNeeded(*this, NULL, bufsize);
 }
 
 wxBufferedOutputStream::~wxBufferedOutputStream()
 }
 
 wxBufferedOutputStream::~wxBufferedOutputStream()
@@ -872,6 +1387,13 @@ wxBufferedOutputStream::~wxBufferedOutputStream()
     delete m_o_streambuf;
 }
 
     delete m_o_streambuf;
 }
 
+bool wxBufferedOutputStream::Close()
+{
+    Sync();
+    return IsOk();
+}
+
+
 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
 {
     m_lastcount = 0;
 wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
 {
     m_lastcount = 0;
@@ -879,13 +1401,13 @@ wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
     return *this;
 }
 
     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);
 }
 
 {
     Sync();
     return m_o_streambuf->Seek(pos, mode);
 }
 
-off_t wxBufferedOutputStream::TellO() const
+wxFileOffset wxBufferedOutputStream::TellO() const
 {
     return m_o_streambuf->Tell();
 }
 {
     return m_o_streambuf->Tell();
 }
@@ -901,19 +1423,27 @@ size_t wxBufferedOutputStream::OnSysWrite(const void *buffer, size_t bufsize)
     return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
 }
 
     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);
 }
 
 {
     return m_parent_o_stream->SeekO(seek, mode);
 }
 
-off_t wxBufferedOutputStream::OnSysTell() const
+wxFileOffset wxBufferedOutputStream::OnSysTell() const
 {
     return m_parent_o_stream->TellO();
 }
 
 {
     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)
+{
+    wxCHECK_RET( buffer, wxT("wxBufferedOutputStream needs buffer") );
+
+    delete m_o_streambuf;
+    m_o_streambuf = buffer;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -922,16 +1452,9 @@ size_t wxBufferedOutputStream::GetSize() const
 
 wxOutputStream& wxEndL(wxOutputStream& stream)
 {
 
 wxOutputStream& wxEndL(wxOutputStream& stream)
 {
-#ifdef __MSW__
-  return stream.Write("\r\n", 2);
-#else
-#ifdef __WXMAC__
-  return stream.Write("\r", 1);
-#else
-  return stream.Write("\n", 1);
-#endif
-#endif
+    static const wxChar *eol = wxTextFile::GetEOL();
+
+    return stream.Write(eol, wxStrlen(eol));
 }
 
 }
 
-#endif
-  // wxUSE_STREAMS
+#endif // wxUSE_STREAMS
wxWidgets (Impactor)