X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/7513f9ffc5f8f6e75d55cc32cafe5ea6a111fcfc..77c8efc8c37da6d6a5e2e8022d21d1cd7d76371d:/src/common/stream.cpp diff --git a/src/common/stream.cpp b/src/common/stream.cpp index 6d3b4edcd5..f7cd2ea2c5 100644 --- a/src/common/stream.cpp +++ b/src/common/stream.cpp @@ -1,666 +1,1005 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: stream.cpp +// Name: src/common/stream.cpp // 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 -// 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__ - #pragma hdrstop + #pragma hdrstop #endif +#if wxUSE_STREAMS + +#include "wx/stream.h" + #ifndef WX_PRECOMP - #include "wx/defs.h" + #include "wx/log.h" #endif -#if wxUSE_STREAMS - #include -#include "wx/stream.h" #include "wx/datstrm.h" -#include "wx/objstrm.h" +#include "wx/textfile.h" +#include "wx/scopeguard.h" -#define BUF_TEMP_SIZE 10000 +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- + +// the temporary buffer size used when copying from stream to stream +#define BUF_TEMP_SIZE 4096 + +// ============================================================================ +// implementation +// ============================================================================ // ---------------------------------------------------------------------------- // 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) - : 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) { - 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() { - 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) { - char *b_start; + SetBufferIO(buffer_start, (char *)buffer_end - (char *)buffer_start, + takeOwnership); +} + +void wxStreamBuffer::SetBufferIO(void *start, + size_t len, + bool takeOwnership) +{ + // 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; + + ResetBuffer(); +} - b_start = new char[bufsize]; - SetBufferIO(b_start, b_start + bufsize); - m_destroybuf = TRUE; +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() { - 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; - else - m_buffer_pos = m_buffer_start; } +// fill the buffer with as much data as possible (only for read buffers) 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; - if (count == 0) - return FALSE; - return TRUE; + m_buffer_end = m_buffer_start + count; + m_buffer_pos = m_buffer_start; + + return true; } +// write the buffer contents to the stream (only for write buffers) 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") ); - if (m_buffer_pos == m_buffer_start || !m_flushable) - return FALSE; + size_t current = m_buffer_pos - m_buffer_start; + size_t count = outStream->OnSysWrite(m_buffer_start, current); + if ( count != current ) + return false; - 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; + m_buffer_pos = m_buffer_start; + + return true; +} + +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) { - 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) { - 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; - - 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; + size_t left = GetBytesLeft(); + + 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) { - wxASSERT(m_stream != NULL); + wxOutputStream *outStream = GetOutputStream(); - if (!m_buffer_size) { - m_stream->OnSysWrite(&c, 1); - return; - } + wxCHECK_RET( outStream, wxT("should have a stream in wxStreamBuffer") ); - if (GetDataLeft() == 0 && !FlushBuffer()) { - CHECK_ERROR(wxStream_WRITE_ERR); - return; - } - - 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 c; - - wxASSERT(m_stream != NULL && m_buffer_size != 0); + wxCHECK_MSG( m_stream && HasBuffer(), 0, + wxT("should have the stream and the buffer in wxStreamBuffer") ); - 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 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) { - wxASSERT(m_stream != NULL); - - if (m_mode == write) - return 0; + wxASSERT_MSG( buffer, wxT("Warning: Null pointer is about to be used") ); - // ------------------ - // Buffering disabled - // ------------------ + /* Clear buffer first */ + memset(buffer, 0x00, size); - m_stream->m_lasterror = wxStream_NOERROR; - if (!m_buffer_size) - return (m_stream->m_lastcount += m_stream->OnSysRead(buffer, size)); + // lasterror is reset before all new IO calls + if ( m_stream ) + m_stream->Reset(); - // ----------------- - // 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; + + do + { + nRead = Read(buf, WXSIZEOF(buf)); + if ( nRead ) + { + nRead = dbuf->Write(buf, nRead); + total += nRead; + } + } + while ( nRead ); - while (bytes_read != 0) { - bytes_read = Read(buf, bytes_read); - bytes_read = s_buf->Write(buf, bytes_read); - s += bytes_read; - } - return s; + return total; } 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 - // ------------------ + if (m_stream) + { + // lasterror is reset before all new IO calls + m_stream->Reset(); + } - size_t buf_left, orig_size = size; + size_t ret; - while (size > 0) { - buf_left = m_buffer_end - m_buffer_pos; + if ( !HasBuffer() && m_fixed ) + { + wxOutputStream *outStream = GetOutputStream(); - // 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. + wxCHECK_MSG( outStream, 0, wxT("should have a stream in wxStreamBuffer") ); - if (!FlushBuffer()) { - CHECK_ERROR(wxStream_WRITE_ERR); - return (m_stream->m_lastcount = orig_size-size); - } + // 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; + } - m_buffer_pos = m_buffer_start; + if (m_stream) + { + // i am not entirely sure what we do this for + m_stream->m_lastcount = ret; + } - } else { + return ret; +} - // Second case: just copy it in the stream buffer. - PutToBuffer(buffer, size); - break; +size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf) +{ + 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") ); + + char buf[BUF_TEMP_SIZE]; + size_t nWrite, + total = 0; + + 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; + } } - } - return (m_stream->m_lastcount = orig_size); + while ( nWrite == WXSIZEOF(buf) ); + + return total; } -size_t wxStreamBuffer::Write(wxStreamBuffer *sbuf) +wxFileOffset wxStreamBuffer::Seek(wxFileOffset pos, wxSeekMode mode) { - char buf[BUF_TEMP_SIZE]; - size_t s = 0, bytes_count = BUF_TEMP_SIZE, b_count2; - wxInputStream *in_stream; + wxFileOffset ret_off, diff; - if (m_mode == read) - return 0; + wxFileOffset last_access = GetLastAccess(); - in_stream = (wxInputStream *)sbuf->Stream(); + if ( !m_flushable ) + { + switch (mode) + { + case wxFromStart: + diff = pos; + break; - 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; -} + case wxFromCurrent: + diff = pos + GetIntPosition(); + break; -off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode) -{ - off_t ret_off, diff, last_access; + case wxFromEnd: + diff = pos + last_access; + break; - last_access = GetLastAccess(); + default: + wxFAIL_MSG( wxT("invalid seek mode") ); - 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; + 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; + wxFileOffset pos; - if (m_flushable) { - pos = m_stream->OnSysTell(); - if (pos == wxInvalidOffset) - return wxInvalidOffset; - return pos - GetLastAccess() + GetIntPosition(); - } else - return GetIntPosition(); -} + // 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; + } -size_t wxStreamBuffer::GetDataLeft() -{ - if (m_buffer_end == m_buffer_pos && m_flushable) - FillBuffer(); - return m_buffer_end-m_buffer_pos; + pos += GetIntPosition(); + + if ( m_mode == read && m_flushable ) + pos -= GetLastAccess(); + + return pos; } // ---------------------------------------------------------------------------- // wxStreamBase // ---------------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject) + wxStreamBase::wxStreamBase() { - m_lasterror = wxStream_NOERROR; - m_lastcount = 0; + m_lasterror = wxSTREAM_NO_ERROR; + m_lastcount = 0; } 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; } // ---------------------------------------------------------------------------- // wxInputStream // ---------------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase) + wxInputStream::wxInputStream() - : wxStreamBase(), - m_wback(NULL), m_wbacksize(0), m_wbackcur(0) { + m_wback = NULL; + m_wbacksize = + m_wbackcur = 0; } wxInputStream::~wxInputStream() { - if (m_wback) free(m_wback); } -char *wxInputStream::AllocSpaceWBack(size_t needed_size) +bool wxInputStream::CanRead() const { - char *temp_b; - size_t toget; + // 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; +} - /* get number of bytes left from previous wback buffer */ - toget = m_wbacksize - m_wbackcur; +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; +} - /* allocate a buffer large enough to hold prev + new data */ - temp_b = (char *) malloc(needed_size + toget); +char *wxInputStream::AllocSpaceWBack(size_t needed_size) +{ + // get number of bytes left from previous wback buffer + size_t toget = m_wbacksize - m_wbackcur; - if (!temp_b) - return NULL; + // allocate a buffer large enough to hold prev + new data + char *temp_b = (char *)malloc(needed_size + toget); - /* 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 (!temp_b) + return NULL; - /* done */ - m_wback = temp_b; - m_wbackcur = 0; - m_wbacksize = needed_size + toget; + // 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); + } - return (char *) m_wback; + // done + m_wback = temp_b; + m_wbackcur = 0; + m_wbacksize = needed_size + toget; + + 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") ); - if (!m_wback) - return 0; + /* Clear buffer first */ + memset(buf, 0x00, size); - if (bsize < s_toget) - s_toget = bsize; + if (!m_wback) + return 0; - memcpy(buf, (m_wback+m_wbackcur), s_toget); + // how many bytes do we have in the buffer? + size_t toget = m_wbacksize - m_wbackcur; - m_wbackcur += s_toget; - if (m_wbackcur == m_wbacksize) { - free(m_wback); - m_wback = (char *)NULL; - m_wbacksize = 0; - m_wbackcur = 0; - } - - return s_toget; + if ( size < toget ) + { + // we won't read everything + toget = size; + } + + // copy the data from the cache + memcpy(buf, m_wback + m_wbackcur, toget); + + m_wbackcur += toget; + if ( m_wbackcur == m_wbacksize ) + { + // TODO: should we really free it here all the time? maybe keep it? + free(m_wback); + m_wback = NULL; + m_wbacksize = 0; + m_wbackcur = 0; + } + + // return the number of bytes copied + return toget; } size_t wxInputStream::Ungetch(const void *buf, size_t bufsize) { - char *ptrback; + wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be used in Ungetch()") ); - ptrback = AllocSpaceWBack(bufsize); - if (!ptrback) - return 0; + 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; + + // Eof() shouldn't return true any longer + if ( m_lasterror == wxSTREAM_EOF ) + m_lasterror = wxSTREAM_NO_ERROR; - memcpy(ptrback, buf, bufsize); - return bufsize; + memcpy(ptrback, buf, bufsize); + return bufsize; } bool wxInputStream::Ungetch(char c) { - char *ptrback; - - 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) { - size_t retsize; - char *buf = (char *)buffer; + wxASSERT_MSG( buf, wxT("Warning: Null pointer is about to be read") ); - retsize = GetWBack(buf, size); - if (retsize == size) { - m_lastcount = size; - m_lasterror = wxStream_NOERROR; - return *this; - } - size -= retsize; - buf += retsize; + char *p = (char *)buf; + m_lastcount = 0; + + size_t read = GetWBack(buf, size); + for ( ;; ) + { + size -= read; + m_lastcount += read; + p += read; + + if ( !size ) + { + // we read the requested amount of data + break; + } - m_lastcount = OnSysRead(buf, size) + retsize; - return *this; + 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; + } + } + + return *this; } char wxInputStream::Peek() { - char c; + char c; + Read(&c, sizeof(c)); + if (m_lasterror == wxSTREAM_NO_ERROR) + { + Ungetch(c); + return c; + } - Read(&c, 1); - if (m_lasterror == wxStream_NOERROR) { - Ungetch(c); - return c; - } - return 0; + 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]; + + for ( ;; ) + { + 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; - while (bytes_read == BUF_TEMP_SIZE) { - bytes_read = Read(buf, bytes_read).LastRead(); - bytes_read = stream_out.Write(buf, bytes_read).LastWrite(); - } - 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 SeeI() to one - // one position, unread some bytes there, SeekI() to another position - // and the data would be corrupted. - if (m_wback) { - free(m_wback); - m_wback = (char*) NULL; - m_wbacksize = 0; - m_wbackcur = 0; - } + // I don't know whether it should be put as well in wxFileInputStream::OnSysSeek + if (m_lasterror==wxSTREAM_EOF) + m_lasterror=wxSTREAM_NO_ERROR; - return OnSysSeek(pos, mode); + // 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 sought 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 + 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); + m_wback = NULL; + m_wbacksize = 0; + m_wbackcur = 0; + } + + 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 // ---------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase) + wxOutputStream::wxOutputStream() - : wxStreamBase() { } @@ -668,247 +1007,531 @@ wxOutputStream::~wxOutputStream() { } +size_t wxOutputStream::OnSysWrite(const void * WXUNUSED(buffer), + size_t WXUNUSED(bufsize)) +{ + return 0; +} + void wxOutputStream::PutC(char c) { - Write((void *) &c, 1); + Write(&c, sizeof(c)); } wxOutputStream& wxOutputStream::Write(const void *buffer, size_t size) { - m_lastcount = OnSysWrite(buffer, size); - return *this; + m_lastcount = OnSysWrite(buffer, size); + return *this; } wxOutputStream& wxOutputStream::Write(wxInputStream& stream_in) { - stream_in.Read(*this); - return *this; + stream_in.Read(*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); } void wxOutputStream::Sync() { } -#if wxUSE_SERIAL -wxOutputStream& wxOutputStream::operator<<(wxObject& obj) -{ - wxObjectOutputStream obj_s(*this); - obj_s.SaveObject(obj); - return *this; -} -#endif // ---------------------------------------------------------------------------- // wxCountingOutputStream // ---------------------------------------------------------------------------- +IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream) + 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; - if (m_currentPos > m_lastcount) m_lastcount = m_currentPos; - return m_currentPos; + m_currentPos += size; + if (m_currentPos > m_lastcount) + m_lastcount = 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; - - return 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; } -off_t wxCountingOutputStream::OnSysTell() const +wxFileOffset wxCountingOutputStream::OnSysTell() const { - return m_currentPos; // ? + return m_currentPos; } - + // ---------------------------------------------------------------------------- // wxFilterInputStream // ---------------------------------------------------------------------------- +IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream) + wxFilterInputStream::wxFilterInputStream() - : wxInputStream() + : m_parent_i_stream(NULL), + m_owns(false) { } 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() { + if (m_owns) + delete m_parent_i_stream; } // ---------------------------------------------------------------------------- // wxFilterOutputStream // ---------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(wxFilterOutputStream, wxOutputStream) + wxFilterOutputStream::wxFilterOutputStream() - : wxOutputStream() + : m_parent_o_stream(NULL), + m_owns(false) { } wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream) - : wxOutputStream() + : m_parent_o_stream(&stream), + m_owns(false) +{ +} + +wxFilterOutputStream::wxFilterOutputStream(wxOutputStream *stream) + : m_parent_o_stream(stream), + m_owns(true) { - m_parent_o_stream = &stream; +} + +bool wxFilterOutputStream::Close() +{ + if (m_parent_o_stream && m_owns) + return m_parent_o_stream->Close(); + else + return true; } 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(wxInputStream& s) - : wxFilterInputStream(s) + +namespace { - m_i_streambuf = new wxStreamBuffer(*this, wxStreamBuffer::read); - m_i_streambuf->SetBufferIO(1024); + +// 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 +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 = CreateBufferIfNeeded(*this, NULL, bufsize); } wxBufferedInputStream::~wxBufferedInputStream() { - delete m_i_streambuf; + m_parent_i_stream->SeekI(-(wxFileOffset)m_i_streambuf->GetBytesLeft(), + wxFromCurrent); + + delete m_i_streambuf; } 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) { - m_lasterror = wxStream_NOERROR; - return *this; - } - size -= retsize; - buf += retsize; + // first read from the already cached data + m_lastcount = GetWBack(buf, size); - m_i_streambuf->Read(buf, size); + // do we have to read anything more? + if ( m_lastcount < size ) + { + size -= m_lastcount; + buf = (char *)buf + m_lastcount; - return *this; + // 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; + + // 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; } -off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode) +wxFileOffset wxBufferedInputStream::SeekI(wxFileOffset pos, wxSeekMode mode) { - return m_i_streambuf->Seek(pos, 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); } -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) { - return m_parent_i_stream->Read(buffer, bufsize).LastRead(); + return m_parent_i_stream->Read(buffer, bufsize).LastRead(); +} + +wxFileOffset wxBufferedInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode) +{ + return m_parent_i_stream->SeekI(seek, mode); } -off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode) +wxFileOffset wxBufferedInputStream::OnSysTell() const { - return m_parent_i_stream->SeekI(seek, mode); + return m_parent_i_stream->TellI(); } -off_t wxBufferedInputStream::OnSysTell() const +void wxBufferedInputStream::SetInputStreamBuffer(wxStreamBuffer *buffer) { - return m_parent_i_stream->TellI(); + wxCHECK_RET( buffer, wxT("wxBufferedInputStream needs buffer") ); + + delete m_i_streambuf; + m_i_streambuf = buffer; } // ---------------------------------------------------------------------------- // 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() { - Sync(); - delete m_o_streambuf; + Sync(); + delete m_o_streambuf; } +bool wxBufferedOutputStream::Close() +{ + Sync(); + return IsOk(); +} + + wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size) { - m_lastcount = 0; - m_o_streambuf->Write(buffer, size); - return *this; + m_lastcount = 0; + m_o_streambuf->Write(buffer, 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); + 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(); } void wxBufferedOutputStream::Sync() { - m_o_streambuf->FlushBuffer(); - m_parent_o_stream->Sync(); + m_o_streambuf->FlushBuffer(); + m_parent_o_stream->Sync(); } 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(); +} + +wxFileOffset wxBufferedOutputStream::GetLength() const +{ + 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; +} + +// --------------------------------------------------------------------------- +// wxWrapperInputStream implementation +// --------------------------------------------------------------------------- + +wxWrapperInputStream::wxWrapperInputStream() +{ + m_lasterror = wxSTREAM_READ_ERROR; +} + +wxWrapperInputStream::wxWrapperInputStream(wxInputStream& stream) + : wxFilterInputStream(stream) +{ + SynchronizeLastError(); +} + +wxWrapperInputStream::wxWrapperInputStream(wxInputStream *stream) + : wxFilterInputStream(stream) +{ + if ( m_parent_i_stream ) + SynchronizeLastError(); + else + m_lasterror = wxSTREAM_READ_ERROR; +} + +void wxWrapperInputStream::InitParentStream(wxInputStream& stream) +{ + wxCHECK_RET( !m_parent_i_stream, "Can't init parent stream twice" ); + + m_parent_i_stream = &stream; + + SynchronizeLastError(); +} + +void wxWrapperInputStream::InitParentStream(wxInputStream* stream) +{ + wxCHECK_RET( !m_parent_i_stream, "Can't init parent stream twice" ); + + m_parent_i_stream = stream; + + if ( m_parent_i_stream ) + { + m_owns = true; + + SynchronizeLastError(); + } +} + +wxFileOffset wxWrapperInputStream::GetLength() const +{ + wxCHECK_MSG(m_parent_i_stream, wxInvalidOffset, "Stream not valid"); + + wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError); + return m_parent_i_stream->GetLength(); +} + +bool wxWrapperInputStream::IsSeekable() const +{ + wxCHECK_MSG(m_parent_i_stream, false, "Stream not valid"); + return m_parent_i_stream->IsSeekable(); +} + +size_t wxWrapperInputStream::OnSysRead(void *buffer, size_t size) +{ + wxCHECK_MSG(m_parent_i_stream, false, "Stream not valid"); + + wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError); + + m_parent_i_stream->Read(buffer, size); + return m_parent_i_stream->LastRead(); +} + +wxFileOffset wxWrapperInputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode) +{ + wxCHECK_MSG(IsSeekable(), false, "Stream not seekable"); + + wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError); + return m_parent_i_stream->SeekI (pos, mode); +} + +wxFileOffset wxWrapperInputStream::OnSysTell() const +{ + wxCHECK_MSG(m_parent_i_stream, false, "Stream not valid"); + + wxON_BLOCK_EXIT_THIS0(wxWrapperInputStream::SynchronizeLastError); + return m_parent_i_stream->TellI(); } // ---------------------------------------------------------------------------- @@ -917,16 +1540,9 @@ off_t wxBufferedOutputStream::OnSysTell() const 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