// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "stream.h"
-#endif
-
// 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 <ctype.h>
-#include "wx/stream.h"
#include "wx/datstrm.h"
#include "wx/textfile.h"
-#include "wx/log.h"
// ----------------------------------------------------------------------------
// constants
void wxStreamBuffer::FreeBuffer()
{
if ( m_destroybuf )
+ {
free(m_buffer_start);
+ m_buffer_start = NULL;
+ }
}
wxStreamBuffer::~wxStreamBuffer()
void wxStreamBuffer::SetBufferIO(size_t bufsize)
{
- // start by freeing the old buffer
- FreeBuffer();
-
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();
}
}
: m_buffer_start;
}
+void wxStreamBuffer::Truncate()
+{
+ size_t new_size = m_buffer_pos - m_buffer_start;
+ if ( new_size == m_buffer_size )
+ return;
+
+ if ( !new_size )
+ {
+ FreeBuffer();
+ InitBuffer();
+ return;
+ }
+
+ char *new_start = (char *)realloc(m_buffer_start, new_size);
+ wxCHECK_RET( new_size, _T("shrinking buffer shouldn't fail") );
+
+ m_buffer_start = new_start;
+ m_buffer_size = new_size;
+ m_buffer_end = m_buffer_start + m_buffer_size;
+ m_buffer_pos = m_buffer_end;
+}
+
// fill the buffer with as much data as possible (only for read buffers)
bool wxStreamBuffer::FillBuffer()
{
size_t wxStreamBuffer::Read(void *buffer, size_t size)
{
+ wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be used") );
+
+ /* Clear buffer first */
+ memset(buffer, 0x00, size);
+
// lasterror is reset before all new IO calls
if ( m_stream )
m_stream->Reset();
- size_t read;
+ size_t readBytes;
if ( !HasBuffer() )
{
wxInputStream *inStream = GetInputStream();
wxCHECK_MSG( inStream, 0, _T("should have a stream in wxStreamBuffer") );
- read = inStream->OnSysRead(buffer, size);
+ readBytes = inStream->OnSysRead(buffer, size);
}
else // we have a buffer, use it
{
}
}
- read = orig_size - size;
+ readBytes = orig_size - size;
}
if ( m_stream )
- m_stream->m_lastcount = read;
+ m_stream->m_lastcount = readBytes;
- return read;
+ return readBytes;
}
// this should really be called "Copy()"
do
{
- nRead = Read(dbuf, WXSIZEOF(buf));
+ nRead = Read(buf, WXSIZEOF(buf));
if ( nRead )
{
nRead = dbuf->Write(buf, nRead);
size_t wxStreamBuffer::Write(const void *buffer, size_t size)
{
+ wxASSERT_MSG( buffer, _T("Warning: Null pointer is about to be send") );
+
if (m_stream)
{
// lasterror is reset before all new IO calls
return total;
}
-off_t wxStreamBuffer::Seek(off_t pos, wxSeekMode mode)
+wxFileOffset wxStreamBuffer::Seek(wxFileOffset pos, wxSeekMode mode)
{
- off_t ret_off, diff;
+ wxFileOffset ret_off, diff;
- off_t last_access = GetLastAccess();
+ wxFileOffset last_access = GetLastAccess();
if ( !m_flushable )
{
}
if (diff < 0 || diff > last_access)
return wxInvalidOffset;
- SetIntPosition(diff);
+ 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;
}
}
else
{
- SetIntPosition(diff);
+ 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 pos;
}
return wxInvalidOffset;
}
-off_t wxStreamBuffer::Tell() const
+wxFileOffset wxStreamBuffer::Tell() const
{
- off_t pos;
+ wxFileOffset pos;
// ask the stream for position if we have a real one
if ( m_stream )
// wxStreamBase
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxStreamBase, wxObject)
+
wxStreamBase::wxStreamBase()
{
m_lasterror = wxSTREAM_NO_ERROR;
{
}
-off_t wxStreamBase::OnSysSeek(off_t WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
+size_t wxStreamBase::GetSize() const
+{
+ wxFileOffset length = GetLength();
+ if ( length == (wxFileOffset)wxInvalidOffset )
+ return 0;
+
+ const size_t len = wx_truncate_cast(size_t, length);
+ wxASSERT_MSG( len == length + size_t(0), _T("large files not supported") );
+
+ return len;
+}
+
+wxFileOffset wxStreamBase::OnSysSeek(wxFileOffset WXUNUSED(seek), wxSeekMode WXUNUSED(mode))
{
return wxInvalidOffset;
}
-off_t wxStreamBase::OnSysTell() const
+wxFileOffset wxStreamBase::OnSysTell() const
{
return wxInvalidOffset;
}
// wxInputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxInputStream, wxStreamBase)
+
wxInputStream::wxInputStream()
{
m_wback = NULL;
size_t wxInputStream::GetWBack(void *buf, size_t size)
{
+ wxASSERT_MSG( buf, _T("Warning: Null pointer is about to be used") );
+
+ /* Clear buffer first */
+ memset(buf, 0x00, size);
+
if (!m_wback)
return 0;
size_t wxInputStream::Ungetch(const void *buf, size_t bufsize)
{
+ wxASSERT_MSG( buf, _T("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 Ungetch(&c, sizeof(c)) != 0;
}
-char wxInputStream::GetC()
+int wxInputStream::GetC()
{
- char c;
+ unsigned char c;
Read(&c, sizeof(c));
- return c;
+ return LastRead() ? c : wxEOF;
}
wxInputStream& wxInputStream::Read(void *buf, size_t size)
{
+ wxASSERT_MSG( buf, _T("Warning: Null pointer is about to be read") );
+
char *p = (char *)buf;
m_lastcount = 0;
wxInputStream& wxInputStream::Read(wxOutputStream& stream_out)
{
+ size_t lastcount = 0;
char buf[BUF_TEMP_SIZE];
for ( ;; )
if ( stream_out.Write(buf, bytes_read).LastWrite() != bytes_read )
break;
+
+ lastcount += bytes_read;
}
+ m_lastcount = lastcount;
+
return *this;
}
-off_t wxInputStream::SeekI(off_t pos, wxSeekMode mode)
+wxFileOffset wxInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
{
// RR: This code is duplicated in wxBufferedInputStream. This is
// not really a good design, but buffered stream are different
return OnSysSeek(pos, mode);
}
-off_t wxInputStream::TellI() const
+wxFileOffset wxInputStream::TellI() const
{
- off_t pos = OnSysTell();
+ wxFileOffset pos = OnSysTell();
if (pos != wxInvalidOffset)
pos -= (m_wbacksize - m_wbackcur);
// wxOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxOutputStream, wxStreamBase)
+
wxOutputStream::wxOutputStream()
{
}
return *this;
}
-off_t wxOutputStream::TellO() const
+wxFileOffset wxOutputStream::TellO() const
{
return OnSysTell();
}
-off_t wxOutputStream::SeekO(off_t pos, wxSeekMode mode)
+wxFileOffset wxOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
{
return OnSysSeek(pos, mode);
}
// wxCountingOutputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_DYNAMIC_CLASS(wxCountingOutputStream, wxOutputStream)
+
wxCountingOutputStream::wxCountingOutputStream ()
{
m_currentPos = 0;
}
-size_t wxCountingOutputStream::GetSize() const
+wxFileOffset wxCountingOutputStream::GetLength() const
{
return m_lastcount;
}
return m_currentPos;
}
-off_t wxCountingOutputStream::OnSysSeek(off_t pos, wxSeekMode mode)
+wxFileOffset wxCountingOutputStream::OnSysSeek(wxFileOffset pos, wxSeekMode mode)
{
+ ssize_t new_pos = wx_truncate_cast(ssize_t, pos);
+
switch ( mode )
{
case wxFromStart:
- m_currentPos = pos;
+ wxCHECK_MSG( (wxFileOffset)new_pos == pos, wxInvalidOffset, wxT("huge position not supported") );
break;
case wxFromEnd:
- m_currentPos = m_lastcount + pos;
+ new_pos = m_lastcount + new_pos;
+ wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_lastcount + pos), wxInvalidOffset, wxT("huge position not supported") );
break;
case wxFromCurrent:
- m_currentPos += pos;
+ new_pos = m_currentPos + new_pos;
+ wxCHECK_MSG( (wxFileOffset)new_pos == (wxFileOffset)(m_currentPos + pos), wxInvalidOffset, wxT("huge position not supported") );
break;
default:
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;
}
// wxFilterInputStream
// ----------------------------------------------------------------------------
+IMPLEMENT_ABSTRACT_CLASS(wxFilterInputStream, wxInputStream)
+
wxFilterInputStream::wxFilterInputStream()
+ : m_parent_i_stream(NULL),
+ m_owns(false)
{
- m_parent_i_stream = NULL;
}
wxFilterInputStream::wxFilterInputStream(wxInputStream& stream)
+ : 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()
+ : m_parent_o_stream(NULL),
+ m_owns(false)
{
- m_parent_o_stream = NULL;
}
wxFilterOutputStream::wxFilterOutputStream(wxOutputStream& stream)
+ : m_parent_o_stream(&stream),
+ m_owns(false)
+{
+}
+
+wxFilterOutputStream::wxFilterOutputStream(wxOutputStream *stream)
+ : m_parent_o_stream(stream),
+ m_owns(true)
+{
+}
+
+bool wxFilterOutputStream::Close()
{
- m_parent_o_stream = &stream;
+ 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 wxChar *location) const
+{
+ size_t len = wxStrlen(location);
+
+ for (const wxChar *const *p = GetProtocols(wxSTREAM_FILEEXT); *p; p++)
+ {
+ size_t l = wxStrlen(*p);
+
+ if (l <= len && wxStrcmp(*p, location + len - l) == 0)
+ return len - l;
+ }
+
+ return wxString::npos;
+}
+
+bool wxFilterClassFactoryBase::CanHandle(const wxChar *protocol,
+ wxStreamProtocolType type) const
+{
+ if (type == wxSTREAM_FILEEXT)
+ return FindExtension(protocol) != wxString::npos;
+ else
+ for (const wxChar *const *p = GetProtocols(type); *p; p++)
+ if (wxStrcmp(*p, protocol) == 0)
+ 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()
{
- m_parent_i_stream->SeekI(-(off_t)m_i_streambuf->GetBytesLeft(),
+ m_parent_i_stream->SeekI(-(wxFileOffset)m_i_streambuf->GetBytesLeft(),
wxFromCurrent);
delete m_i_streambuf;
return *this;
}
-off_t wxBufferedInputStream::SeekI(off_t pos, wxSeekMode mode)
+wxFileOffset wxBufferedInputStream::SeekI(wxFileOffset pos, wxSeekMode mode)
{
// RR: Look at wxInputStream for comments.
return m_i_streambuf->Seek(pos, mode);
}
-off_t wxBufferedInputStream::TellI() const
+wxFileOffset wxBufferedInputStream::TellI() const
{
- off_t pos = m_i_streambuf->Tell();
+ wxFileOffset pos = m_i_streambuf->Tell();
if (pos != wxInvalidOffset)
pos -= (m_wbacksize - m_wbackcur);
return m_parent_i_stream->Read(buffer, bufsize).LastRead();
}
-off_t wxBufferedInputStream::OnSysSeek(off_t seek, wxSeekMode mode)
+wxFileOffset wxBufferedInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
{
return m_parent_i_stream->SeekI(seek, mode);
}
-off_t wxBufferedInputStream::OnSysTell() const
+wxFileOffset wxBufferedInputStream::OnSysTell() const
{
return m_parent_i_stream->TellI();
}
delete m_o_streambuf;
}
+bool wxBufferedOutputStream::Close()
+{
+ Sync();
+ return IsOk();
+}
+
+
wxOutputStream& wxBufferedOutputStream::Write(const void *buffer, size_t size)
{
m_lastcount = 0;
return *this;
}
-off_t wxBufferedOutputStream::SeekO(off_t pos, wxSeekMode mode)
+wxFileOffset wxBufferedOutputStream::SeekO(wxFileOffset pos, wxSeekMode mode)
{
Sync();
return m_o_streambuf->Seek(pos, mode);
}
-off_t wxBufferedOutputStream::TellO() const
+wxFileOffset wxBufferedOutputStream::TellO() const
{
return m_o_streambuf->Tell();
}
return m_parent_o_stream->Write(buffer, bufsize).LastWrite();
}
-off_t wxBufferedOutputStream::OnSysSeek(off_t seek, wxSeekMode mode)
+wxFileOffset wxBufferedOutputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
{
return m_parent_o_stream->SeekO(seek, mode);
}
-off_t wxBufferedOutputStream::OnSysTell() const
+wxFileOffset wxBufferedOutputStream::OnSysTell() const
{
return m_parent_o_stream->TellO();
}
-size_t wxBufferedOutputStream::GetSize() const
+wxFileOffset wxBufferedOutputStream::GetLength() const
{
- return m_parent_o_stream->GetSize() + m_o_streambuf->GetIntPosition();
+ return m_parent_o_stream->GetLength() + m_o_streambuf->GetIntPosition();
}
void wxBufferedOutputStream::SetOutputStreamBuffer(wxStreamBuffer *buffer)
return stream.Write(eol, wxStrlen(eol));
}
-#endif
- // wxUSE_STREAMS
+#endif // wxUSE_STREAMS
projects / wxWidgets.git / blobdiff