// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
- #pragma implementation "zipstrm.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#include "wx/buffer.h"
#include "wx/ptr_scpd.h"
#include "wx/wfstream.h"
+#include "wx/link.h"
#include "zlib.h"
// value for the 'version needed to extract' field (20 means 2.0)
IMPLEMENT_DYNAMIC_CLASS(wxZipEntry, wxArchiveEntry)
IMPLEMENT_DYNAMIC_CLASS(wxZipClassFactory, wxArchiveClassFactory)
-//FORCE_LINK_ME(zipstrm)
-int _wx_link_dummy_func_zipstrm();
-int _wx_link_dummy_func_zipstrm()
-{
- return 1;
-}
+wxFORCE_LINK_THIS_MODULE(zipstrm)
/////////////////////////////////////////////////////////////////////////////
size_t wxStoredInputStream::OnSysRead(void *buffer, size_t size)
{
- size_t count = wxMin(size, (size_t)(m_len - m_pos));
+ size_t count = wx_truncate_cast(size_t,
+ wxMin(size + wxFileOffset(0), m_len - m_pos + size_t(0)));
count = m_parent_i_stream->Read(buffer, count).LastRead();
m_pos += count;
wxZipMemory *Unique(size_t size);
private:
- ~wxZipMemory() { delete m_data; }
+ ~wxZipMemory() { delete [] m_data; }
char *m_data;
size_t m_size;
}
if (zm->m_capacity < size) {
- delete zm->m_data;
+ delete [] zm->m_data;
zm->m_data = new char[size];
zm->m_capacity = size;
}
// Collection of weak references to entries
WX_DECLARE_HASH_MAP(long, wxZipEntry*, wxIntegerHash,
- wxIntegerEqual, _wxOffsetZipEntryMap);
+ wxIntegerEqual, wx__OffsetZipEntryMap);
class wxZipWeakLinks
{
wxZipWeakLinks *AddEntry(wxZipEntry *entry, wxFileOffset key);
void RemoveEntry(wxFileOffset key)
- { m_entries.erase((_wxOffsetZipEntryMap::key_type)key); }
+ { m_entries.erase(wx_truncate_cast(key_type, key)); }
wxZipEntry *GetEntry(wxFileOffset key) const;
bool IsEmpty() const { return m_entries.empty(); }
private:
+ typedef wx__OffsetZipEntryMap::key_type key_type;
+
~wxZipWeakLinks() { wxASSERT(IsEmpty()); }
int m_ref;
- _wxOffsetZipEntryMap m_entries;
+ wx__OffsetZipEntryMap m_entries;
};
wxZipWeakLinks *wxZipWeakLinks::AddEntry(wxZipEntry *entry, wxFileOffset key)
{
- m_entries[(_wxOffsetZipEntryMap::key_type)key] = entry;
+ m_entries[wx_truncate_cast(key_type, key)] = entry;
m_ref++;
return this;
}
wxZipEntry *wxZipWeakLinks::GetEntry(wxFileOffset key) const
{
- _wxOffsetZipEntryMap::const_iterator it =
- m_entries.find((_wxOffsetZipEntryMap::key_type)key);
+ wx__OffsetZipEntryMap::const_iterator it =
+ m_entries.find(wx_truncate_cast(key_type, key));
return it != m_entries.end() ? it->second : NULL;
}
{
bool isDir = IsDir() && !m_Name.empty();
+ // optimisations for common (and easy) cases
switch (wxFileName::GetFormat(format)) {
case wxPATH_DOS:
{
const wxWX2MBbuf name_buf = conv.cWX2MB(unixName);
const char *name = name_buf;
if (!name) name = "";
- wxUint16 nameLen = (wxUint16)strlen(name);
+ wxUint16 nameLen = wx_truncate_cast(wxUint16, strlen(name));
wxDataOutputStream ds(stream);
ds.Write32(GetDateTime().GetAsDOS());
ds.Write32(m_Crc);
- ds.Write32(m_CompressedSize != wxInvalidOffset ? (wxUint32)m_CompressedSize : 0);
- ds.Write32(m_Size != wxInvalidOffset ? (wxUint32)m_Size : 0);
+ ds.Write32(m_CompressedSize != wxInvalidOffset ?
+ wx_truncate_cast(wxUint32, m_CompressedSize) : 0);
+ ds.Write32(m_Size != wxInvalidOffset ?
+ wx_truncate_cast(wxUint32, m_Size) : 0);
ds << nameLen;
- wxUint16 extraLen = (wxUint16)GetLocalExtraLen();
+ wxUint16 extraLen = wx_truncate_cast(wxUint16, GetLocalExtraLen());
ds.Write16(extraLen);
stream.Write(name, nameLen);
const wxWX2MBbuf name_buf = conv.cWX2MB(unixName);
const char *name = name_buf;
if (!name) name = "";
- wxUint16 nameLen = (wxUint16)strlen(name);
+ wxUint16 nameLen = wx_truncate_cast(wxUint16, strlen(name));
const wxWX2MBbuf comment_buf = conv.cWX2MB(m_Comment);
const char *comment = comment_buf;
if (!comment) comment = "";
- wxUint16 commentLen = (wxUint16)strlen(comment);
+ wxUint16 commentLen = wx_truncate_cast(wxUint16, strlen(comment));
- wxUint16 extraLen = (wxUint16)GetExtraLen();
+ wxUint16 extraLen = wx_truncate_cast(wxUint16, GetExtraLen());
wxDataOutputStream ds(stream);
ds << CENTRAL_MAGIC << m_VersionMadeBy << m_SystemMadeBy;
- ds.Write16((wxUint16)GetVersionNeeded());
- ds.Write16((wxUint16)GetFlags());
- ds.Write16((wxUint16)GetMethod());
+ ds.Write16(wx_truncate_cast(wxUint16, GetVersionNeeded()));
+ ds.Write16(wx_truncate_cast(wxUint16, GetFlags()));
+ ds.Write16(wx_truncate_cast(wxUint16, GetMethod()));
ds.Write32(GetDateTime().GetAsDOS());
ds.Write32(GetCrc());
- ds.Write32((wxUint32)GetCompressedSize());
- ds.Write32((wxUint32)GetSize());
+ ds.Write32(wx_truncate_cast(wxUint32, GetCompressedSize()));
+ ds.Write32(wx_truncate_cast(wxUint32, GetSize()));
ds.Write16(nameLen);
ds.Write16(extraLen);
ds << commentLen << m_DiskStart << m_InternalAttributes
- << m_ExternalAttributes << (wxUint32)GetOffset();
+ << m_ExternalAttributes << wx_truncate_cast(wxUint32, GetOffset());
stream.Write(name, nameLen);
if (extraLen)
{
// it's an info-zip record as expected
stream.Ungetch(buf + 4, sizeof(buf) - 4);
- m_Crc = (wxUint32)m_CompressedSize;
+ m_Crc = wx_truncate_cast(wxUint32, m_CompressedSize);
m_CompressedSize = m_Size;
m_Size = u1;
return SUMS_SIZE + 4;
wxDataOutputStream ds(stream);
ds.Write32(crc);
- ds.Write32((wxUint32)compressedSize);
- ds.Write32((wxUint32)size);
+ ds.Write32(wx_truncate_cast(wxUint32, compressedSize));
+ ds.Write32(wx_truncate_cast(wxUint32, size));
return SUMS_SIZE;
}
wxFileOffset GetOffset() const { return m_Offset; }
wxString GetComment() const { return m_Comment; }
- void SetDiskNumber(int num) { m_DiskNumber = (wxUint16)num; }
- void SetStartDisk(int num) { m_StartDisk = (wxUint16)num; }
- void SetEntriesHere(int num) { m_EntriesHere = (wxUint16)num; }
- void SetTotalEntries(int num) { m_TotalEntries = (wxUint16)num; }
- void SetSize(wxFileOffset size) { m_Size = (wxUint32)size; }
- void SetOffset(wxFileOffset offset) { m_Offset = (wxUint32)offset; }
- void SetComment(const wxString& comment) { m_Comment = comment; }
+ void SetDiskNumber(int num)
+ { m_DiskNumber = wx_truncate_cast(wxUint16, num); }
+ void SetStartDisk(int num)
+ { m_StartDisk = wx_truncate_cast(wxUint16, num); }
+ void SetEntriesHere(int num)
+ { m_EntriesHere = wx_truncate_cast(wxUint16, num); }
+ void SetTotalEntries(int num)
+ { m_TotalEntries = wx_truncate_cast(wxUint16, num); }
+ void SetSize(wxFileOffset size)
+ { m_Size = wx_truncate_cast(wxUint32, size); }
+ void SetOffset(wxFileOffset offset)
+ { m_Offset = wx_truncate_cast(wxUint32, offset); }
+ void SetComment(const wxString& comment)
+ { m_Comment = comment; }
bool Read(wxInputStream& stream, wxMBConv& conv);
bool Write(wxOutputStream& stream, wxMBConv& conv) const;
/////////////////////////////////////////////////////////////////////////////
// Input stream
-wxDECLARE_SCOPED_PTR(wxZipEntry, _wxZipEntryPtr)
-wxDEFINE_SCOPED_PTR (wxZipEntry, _wxZipEntryPtr)
+// leave the default wxZipEntryPtr free for users
+wxDECLARE_SCOPED_PTR(wxZipEntry, wx__ZipEntryPtr)
+wxDEFINE_SCOPED_PTR (wxZipEntry, wx__ZipEntryPtr)
// constructor
//
wxMBConv& conv /*=wxConvLocal*/)
: wxArchiveInputStream(stream, conv)
{
- m_ffile = NULL;
Init();
}
-// Compatibility constructor
+#if 1 //WXWIN_COMPATIBILITY_2_6
+
+// Part of the compatibility constructor, which has been made inline to
+// avoid a problem with it not being exported by mingw 3.2.3
//
-wxZipInputStream::wxZipInputStream(const wxString& archive,
- const wxString& file)
- : wxArchiveInputStream(OpenFile(archive), wxConvLocal)
+void wxZipInputStream::Init(const wxString& file)
{
// no error messages
wxLogNull nolog;
Init();
- _wxZipEntryPtr entry;
+ m_allowSeeking = true;
+ m_ffile = wx_static_cast(wxFFileInputStream*, m_parent_i_stream);
+ wx__ZipEntryPtr entry;
if (m_ffile->Ok()) {
do {
wxInputStream& wxZipInputStream::OpenFile(const wxString& archive)
{
wxLogNull nolog;
- m_ffile = new wxFFileInputStream(archive);
- return *m_ffile;
+ return *new wxFFileInputStream(archive);
}
+#endif // WXWIN_COMPATIBILITY_2_6
+
void wxZipInputStream::Init()
{
m_store = new wxStoredInputStream(*m_parent_i_stream);
m_signature = 0;
m_TotalEntries = 0;
m_lasterror = m_parent_i_stream->GetLastError();
+ m_ffile = NULL;
+#if 1 //WXWIN_COMPATIBILITY_2_6
+ m_allowSeeking = false;
+#endif
}
wxZipInputStream::~wxZipInputStream()
wxFileOffset minpos = wxMax(pos - 65535L, 0);
while (pos > minpos) {
- size_t len = (size_t)(pos - wxMax(pos - (BUFSIZE - 3), minpos));
+ size_t len = wx_truncate_cast(size_t,
+ pos - wxMax(pos - (BUFSIZE - 3), minpos));
memcpy(buf.data() + len, buf, 3);
pos -= len;
if (!IsOk())
return NULL;
- _wxZipEntryPtr entry(new wxZipEntry(m_entry));
+ wx__ZipEntryPtr entry(new wxZipEntry(m_entry));
entry->m_backlink = m_weaklinks->AddEntry(entry.get(), entry->GetKey());
return entry.release();
}
return count;
}
+#if 1 //WXWIN_COMPATIBILITY_2_6
+
// Borrowed from VS's zip stream (c) 1999 Vaclav Slavik
//
wxFileOffset wxZipInputStream::OnSysSeek(wxFileOffset seek, wxSeekMode mode)
{
- if (!m_ffile)
+ // seeking works when the stream is created with the compatibility
+ // constructor
+ if (!m_allowSeeking)
return wxInvalidOffset;
if (!IsOpened())
if ((AtHeader() && !DoOpen()) || !OpenDecompressor())
default : nextpos = pos; break; /* just to fool compiler, never happens */
}
- size_t toskip wxDUMMY_INITIALIZE(0);
+ wxFileOffset toskip wxDUMMY_INITIALIZE(0);
if ( nextpos >= pos )
{
- toskip = (size_t)(nextpos - pos);
+ toskip = nextpos - pos;
}
else
{
m_lasterror = wxSTREAM_READ_ERROR;
return pos;
}
- toskip = (size_t)nextpos;
+ toskip = nextpos;
}
if ( toskip > 0 )
{
- const size_t BUFSIZE = 4096;
+ const int BUFSIZE = 4096;
size_t sz;
char buffer[BUFSIZE];
while ( toskip > 0 )
{
- sz = wxMin(toskip, BUFSIZE);
+ sz = wx_truncate_cast(size_t, wxMin(toskip, BUFSIZE));
Read(buffer, sz);
toskip -= sz;
}
return pos;
}
+#endif // WXWIN_COMPATIBILITY_2_6
+
/////////////////////////////////////////////////////////////////////////////
// Output stream
#include "wx/listimpl.cpp"
-WX_DEFINE_LIST(_wxZipEntryList);
+WX_DEFINE_LIST(wx__ZipEntryList)
wxZipOutputStream::wxZipOutputStream(wxOutputStream& stream,
int level /*=-1*/,
wxZipOutputStream::~wxZipOutputStream()
{
Close();
- WX_CLEAR_LIST(_wxZipEntryList, m_entries);
+ WX_CLEAR_LIST(wx__ZipEntryList, m_entries);
delete m_store;
delete m_deflate;
delete m_pending;
bool wxZipOutputStream::CopyEntry(wxZipEntry *entry,
wxZipInputStream& inputStream)
{
- _wxZipEntryPtr e(entry);
+ wx__ZipEntryPtr e(entry);
return
inputStream.DoOpen(e.get(), true) &&
void wxZipOutputStream::CreatePendingEntry(const void *buffer, size_t size)
{
wxASSERT(IsOk() && m_pending && !m_comp);
- _wxZipEntryPtr spPending(m_pending);
+ wx__ZipEntryPtr spPending(m_pending);
m_pending = NULL;
Buffer bufs[] = {
void wxZipOutputStream::CreatePendingEntry()
{
wxASSERT(IsOk() && m_pending && !m_comp);
- _wxZipEntryPtr spPending(m_pending);
+ wx__ZipEntryPtr spPending(m_pending);
m_pending = NULL;
m_lasterror = wxSTREAM_WRITE_ERROR;
endrec.SetOffset(m_headerOffset);
endrec.SetComment(m_Comment);
- _wxZipEntryList::iterator it;
+ wx__ZipEntryList::iterator it;
wxFileOffset size = 0;
for (it = m_entries.begin(); it != m_entries.end(); ++it) {
projects / wxWidgets.git / blobdiff