seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Common/StreamObjects.cpp

@@ -2,18 +2,55 @@
 
 #include "StdAfx.h"
 
+#include <stdlib.h>
+
 #include "../../../C/Alloc.h"
 
 #include "StreamObjects.h"
 
+STDMETHODIMP CBufferInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  if (size == 0)
+    return S_OK;
+  if (_pos >= Buf.Size())
+    return S_OK;
+  size_t rem = Buf.Size() - (size_t)_pos;
+  if (rem > size)
+    rem = (size_t)size;
+  memcpy(data, (const Byte *)Buf + (size_t)_pos, rem);
+  _pos += rem;
+  if (processedSize)
+    *processedSize = (UInt32)rem;
+  return S_OK;
+}
+
+STDMETHODIMP CBufferInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  switch (seekOrigin)
+  {
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _pos; break;
+    case STREAM_SEEK_END: offset += Buf.Size(); break;
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _pos = offset;
+  if (newPosition)
+    *newPosition = offset;
+  return S_OK;
+}
+
 STDMETHODIMP CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
   if (size == 0)
     return S_OK;
-  if (_pos > _size)
-    return E_FAIL;
+  if (_pos >= _size)
+    return S_OK;
   size_t rem = _size - (size_t)_pos;
   if (rem > size)
     rem = (size_t)size;
@@ -26,26 +63,48 @@ STDMETHODIMP CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 
 STDMETHODIMP CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
-  switch(seekOrigin)
+  switch (seekOrigin)
   {
-    case STREAM_SEEK_SET: _pos = offset; break;
-    case STREAM_SEEK_CUR: _pos += offset; break;
-    case STREAM_SEEK_END: _pos = _size + offset; break;
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _pos; break;
+    case STREAM_SEEK_END: offset += _size; break;
     default: return STG_E_INVALIDFUNCTION;
   }
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _pos = offset;
   if (newPosition)
-    *newPosition = _pos;
+    *newPosition = offset;
   return S_OK;
 }
 
-void CByteDynBuffer::Free()
+void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream)
+{
+  *stream = NULL;
+  CBufInStream *inStreamSpec = new CBufInStream;
+  CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
+  inStreamSpec->Init((const Byte *)data, size, ref);
+  *stream = streamTemp.Detach();
+}
+
+void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream)
+{
+  *stream = NULL;
+  CBufferInStream *inStreamSpec = new CBufferInStream;
+  CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
+  inStreamSpec->Buf.CopyFrom((const Byte *)data, size);
+  inStreamSpec->Init();
+  *stream = streamTemp.Detach();
+}
+
+void CByteDynBuffer::Free() throw()
 {
   free(_buf);
   _buf = 0;
   _capacity = 0;
 }
 
-bool CByteDynBuffer::EnsureCapacity(size_t cap)
+bool CByteDynBuffer::EnsureCapacity(size_t cap) throw()
 {
   if (cap <= _capacity)
     return true;
@@ -77,8 +136,7 @@ Byte *CDynBufSeqOutStream::GetBufPtrForWriting(size_t addSize)
 
 void CDynBufSeqOutStream::CopyToBuffer(CByteBuffer &dest) const
 {
-  dest.SetCapacity(_size);
-  memcpy((Byte *)dest, (const Byte *)_buffer, _size);
+  dest.CopyFrom((const Byte *)_buffer, _size);
 }
 
 STDMETHODIMP CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
@@ -102,8 +160,11 @@ STDMETHODIMP CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *p
   size_t rem = _size - _pos;
   if (rem > size)
     rem = (size_t)size;
-  memcpy(_buffer + _pos, data, rem);
-  _pos += rem;
+  if (rem != 0)
+  {
+    memcpy(_buffer + _pos, data, rem);
+    _pos += rem;
+  }
   if (processedSize)
     *processedSize = (UInt32)rem;
   return (rem != 0 || size == 0) ? S_OK : E_FAIL;
@@ -121,7 +182,7 @@ STDMETHODIMP CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size,
 
 static const UInt64 kEmptyTag = (UInt64)(Int64)-1;
 
-void CCachedInStream::Free()
+void CCachedInStream::Free() throw()
 {
   MyFree(_tags);
   _tags = 0;
@@ -129,7 +190,7 @@ void CCachedInStream::Free()
   _data = 0;
 }
 
-bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog)
+bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw()
 {
   unsigned sizeLog = blockSizeLog + numBlocksLog;
   if (sizeLog >= sizeof(size_t) * 8)
@@ -155,7 +216,7 @@ bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog)
   return true;
 }
 
-void CCachedInStream::Init(UInt64 size)
+void CCachedInStream::Init(UInt64 size) throw()
 {
   _size = size;
   _pos = 0;
@@ -170,8 +231,8 @@ STDMETHODIMP CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
     *processedSize = 0;
   if (size == 0)
     return S_OK;
-  if (_pos > _size)
-    return E_FAIL;
+  if (_pos >= _size)
+    return S_OK;
 
   {
     UInt64 rem = _size - _pos;
@@ -208,14 +269,17 @@ STDMETHODIMP CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
  
 STDMETHODIMP CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
-  switch(seekOrigin)
+  switch (seekOrigin)
   {
-    case STREAM_SEEK_SET: _pos = offset; break;
-    case STREAM_SEEK_CUR: _pos = _pos + offset; break;
-    case STREAM_SEEK_END: _pos = _size + offset; break;
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _pos; break;
+    case STREAM_SEEK_END: offset += _size; break;
     default: return STG_E_INVALIDFUNCTION;
   }
-  if (newPosition != 0)
-    *newPosition = _pos;
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _pos = offset;
+  if (newPosition)
+    *newPosition = offset;
   return S_OK;
 }

data/ext/p7zip/CPP/7zip/Common/StreamObjects.h

@@ -3,10 +3,27 @@
 #ifndef __STREAM_OBJECTS_H
 #define __STREAM_OBJECTS_H
 
-#include "../../Common/Buffer.h"
+#include "../../Common/MyBuffer.h"
 #include "../../Common/MyCom.h"
+#include "../../Common/MyVector.h"
+
 #include "../IStream.h"
 
+class CBufferInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  UInt64 _pos;
+public:
+  CByteBuffer Buf;
+  void Init() { _pos = 0; }
+ 
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+};
+
 struct CReferenceBuf:
   public IUnknown,
   public CMyUnknownImp
@@ -31,13 +48,18 @@ public:
     _pos = 0;
     _ref = ref;
   }
-  void Init(CReferenceBuf *ref) { Init(ref->Buf, ref->Buf.GetCapacity(), ref); }
+  void Init(CReferenceBuf *ref) { Init(ref->Buf, ref->Buf.Size(), ref); }
 
-  MY_UNKNOWN_IMP1(IInStream)
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
   STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
 };
 
+void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream);
+void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream);
+inline void Create_BufInStream_WithNewBuffer(const CByteBuffer &buf, ISequentialInStream **stream)
+  { Create_BufInStream_WithNewBuffer(buf, buf.Size(), stream); }
+
 class CByteDynBuffer
 {
   size_t _capacity;
@@ -46,11 +68,11 @@ public:
   CByteDynBuffer(): _capacity(0), _buf(0) {};
   // there is no copy constructor. So don't copy this object.
   ~CByteDynBuffer() { Free(); }
-  void Free();
-  size_t GetCapacity() const { return  _capacity; }
-  operator Byte*() const { return _buf; };
-  operator const Byte*() const { return _buf; };
-  bool EnsureCapacity(size_t capacity);
+  void Free() throw();
+  size_t GetCapacity() const { return _capacity; }
+  operator Byte*() const { return _buf; }
+  operator const Byte*() const { return _buf; }
+  bool EnsureCapacity(size_t capacity) throw();
 };
 
 class CDynBufSeqOutStream:
@@ -68,7 +90,7 @@ public:
   Byte *GetBufPtrForWriting(size_t addSize);
   void UpdateSize(size_t addSize) { _size += addSize; }
 
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };
 
@@ -88,7 +110,7 @@ public:
   }
   size_t GetPos() const { return _pos; }
 
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };
 
@@ -103,7 +125,7 @@ public:
   void Init() { _size = 0; }
   UInt64 GetSize() const { return _size; }
 
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };
 
@@ -123,9 +145,9 @@ protected:
 public:
   CCachedInStream(): _tags(0), _data(0) {}
   virtual ~CCachedInStream() { Free(); } // the destructor must be virtual (release calls it) !!!
-  void Free();
-  bool Alloc(unsigned blockSizeLog, unsigned numBlocksLog);
-  void Init(UInt64 size);
+  void Free() throw();
+  bool Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw();
+  void Init(UInt64 size) throw();
 
   MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);

data/ext/p7zip/CPP/7zip/Common/StreamUtils.cpp

@@ -6,7 +6,7 @@
 
 static const UInt32 kBlockSize = ((UInt32)1 << 31);
 
-HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *processedSize)
+HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *processedSize) throw()
 {
   size_t size = *processedSize;
   *processedSize = 0;
@@ -25,21 +25,21 @@ HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *processedSiz
   return S_OK;
 }
 
-HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size)
+HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size) throw()
 {
   size_t processedSize = size;
   RINOK(ReadStream(stream, data, &processedSize));
   return (size == processedSize) ? S_OK : S_FALSE;
 }
 
-HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size)
+HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size) throw()
 {
   size_t processedSize = size;
   RINOK(ReadStream(stream, data, &processedSize));
   return (size == processedSize) ? S_OK : E_FAIL;
 }
 
-HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size)
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size) throw()
 {
   while (size != 0)
   {

data/ext/p7zip/CPP/7zip/Common/StreamUtils.h

@@ -1,13 +1,13 @@
 // StreamUtils.h
 
-#ifndef __STREAMUTILS_H
-#define __STREAMUTILS_H
+#ifndef __STREAM_UTILS_H
+#define __STREAM_UTILS_H
 
 #include "../IStream.h"
 
-HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *size);
-HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size);
-HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size);
-HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size);
+HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *size) throw();
+HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size) throw();
+HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size) throw();
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size) throw();
 
 #endif

data/ext/p7zip/CPP/7zip/Common/UniqBlocks.cpp

@@ -0,0 +1,57 @@
+// UniqBlocks.cpp
+
+#include "StdAfx.h"
+
+#include <string.h>
+
+#include "UniqBlocks.h"
+
+unsigned CUniqBlocks::AddUniq(const Byte *data, size_t size)
+{
+  unsigned left = 0, right = Sorted.Size();
+  while (left != right)
+  {
+    unsigned mid = (left + right) / 2;
+    unsigned index = Sorted[mid];
+    const CByteBuffer &buf = Bufs[index];
+    size_t sizeMid = buf.Size();
+    if (size < sizeMid)
+      right = mid;
+    else if (size > sizeMid)
+      left = mid + 1;
+    else
+    {
+      if (size == 0)
+        return index;
+      int cmp = memcmp(data, buf, size);
+      if (cmp == 0)
+        return index;
+      if (cmp < 0)
+        right = mid;
+      else
+        left = mid + 1;
+    }
+  }
+  unsigned index = Bufs.Size();
+  Sorted.Insert(left, index);
+  Bufs.AddNew().CopyFrom(data, size);
+  return index;
+}
+
+UInt64 CUniqBlocks::GetTotalSizeInBytes() const
+{
+  UInt64 size = 0;
+  FOR_VECTOR (i, Bufs)
+    size += Bufs[i].Size();
+  return size;
+}
+
+void CUniqBlocks::GetReverseMap()
+{
+  unsigned num = Sorted.Size();
+  BufIndexToSortedIndex.ClearAndSetSize(num);
+  unsigned *p = &BufIndexToSortedIndex[0];
+  const unsigned *sorted = &Sorted[0];
+  for (unsigned i = 0; i < num; i++)
+    p[sorted[i]] = i;
+}

data/ext/p7zip/CPP/7zip/Common/UniqBlocks.h

@@ -0,0 +1,26 @@
+// UniqBlocks.h
+
+#ifndef __UNIQ_BLOCKS_H
+#define __UNIQ_BLOCKS_H
+
+#include "../../Common/MyTypes.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/MyVector.h"
+
+struct CUniqBlocks
+{
+  CObjectVector<CByteBuffer> Bufs;
+  CUIntVector Sorted;
+  CUIntVector BufIndexToSortedIndex;
+
+  unsigned AddUniq(const Byte *data, size_t size);
+  UInt64 GetTotalSizeInBytes() const;
+  void GetReverseMap();
+
+  bool IsOnlyEmpty() const
+  {
+    return (Bufs.Size() == 0 || Bufs.Size() == 1 && Bufs[0].Size() == 0);
+  }
+};
+
+#endif

data/ext/p7zip/CPP/7zip/Common/VirtThread.cpp

@@ -10,7 +10,7 @@ static THREAD_FUNC_DECL CoderThread(void *p)
   {
     CVirtThread *t = (CVirtThread *)p;
     t->StartEvent.Lock();
-    if (t->ExitEvent)
+    if (t->Exit)
       return 0;
     t->Execute();
     t->FinishedEvent.Set();
@@ -23,7 +23,7 @@ WRes CVirtThread::Create()
   RINOK(FinishedEvent.CreateIfNotCreated());
   StartEvent.Reset();
   FinishedEvent.Reset();
-  ExitEvent = false;
+  Exit = false;
   if (Thread.IsCreated())
     return S_OK;
   return Thread.Create(CoderThread, this);
@@ -31,16 +31,18 @@ WRes CVirtThread::Create()
 
 void CVirtThread::Start()
 {
-  ExitEvent = false;
+  Exit = false;
   StartEvent.Set();
 }
 
-CVirtThread::~CVirtThread()
+void CVirtThread::WaitThreadFinish()
 {
-  ExitEvent = true;
+  Exit = true;
   if (StartEvent.IsCreated())
     StartEvent.Set();
   if (Thread.IsCreated())
+  {
     Thread.Wait();
+    Thread.Close();
+  }
 }
-

data/ext/p7zip/CPP/7zip/Common/VirtThread.h

@@ -1,7 +1,7 @@
 // VirtThread.h
 
-#ifndef __VIRTTHREAD_H
-#define __VIRTTHREAD_H
+#ifndef __VIRT_THREAD_H
+#define __VIRT_THREAD_H
 
 #include "../../Windows/Synchronization.h"
 #include "../../Windows/Thread.h"
@@ -11,13 +11,14 @@ struct CVirtThread
   NWindows::NSynchronization::CAutoResetEvent StartEvent;
   NWindows::NSynchronization::CAutoResetEvent FinishedEvent;
   NWindows::CThread Thread;
-  bool ExitEvent;
+  bool Exit;
 
-  ~CVirtThread();
+  ~CVirtThread() { WaitThreadFinish(); }
+  void WaitThreadFinish(); // call it in destructor of child class !
   WRes Create();
   void Start();
-  void WaitFinish() { FinishedEvent.Lock(); }
   virtual void Execute() = 0;
+  void WaitExecuteFinish() { FinishedEvent.Lock(); }
 };
 
 #endif

data/ext/p7zip/CPP/7zip/Compress/BZip2Const.h

@@ -25,29 +25,30 @@ const Byte kBlockSig3 = 0x26;
 const Byte kBlockSig4 = 0x53;
 const Byte kBlockSig5 = 0x59;
 
-const int kNumOrigBits = 24;
+const unsigned kNumOrigBits = 24;
 
-const int kNumTablesBits = 3;
-const int kNumTablesMin = 2;
-const int kNumTablesMax = 6;
+const unsigned kNumTablesBits = 3;
+const unsigned kNumTablesMin = 2;
+const unsigned kNumTablesMax = 6;
 
-const int kNumLevelsBits = 5;
+const unsigned kNumLevelsBits = 5;
 
-const int kMaxHuffmanLen = 20; // Check it
+const unsigned kMaxHuffmanLen = 20; // Check it
 
-const int kMaxAlphaSize = 258;
+const unsigned kMaxAlphaSize = 258;
 
-const int kGroupSize = 50;
+const unsigned kGroupSize = 50;
+
+const unsigned kBlockSizeMultMin = 1;
+const unsigned kBlockSizeMultMax = 9;
 
-const int kBlockSizeMultMin = 1;
-const int kBlockSizeMultMax = 9;
 const UInt32 kBlockSizeStep = 100000;
 const UInt32 kBlockSizeMax = kBlockSizeMultMax * kBlockSizeStep;
 
-const int kNumSelectorsBits = 15;
+const unsigned kNumSelectorsBits = 15;
 const UInt32 kNumSelectorsMax = (2 + (kBlockSizeMax / kGroupSize));
 
-const int kRleModeRepSize = 4;
+const unsigned kRleModeRepSize = 4;
 
 }}
 

data/ext/p7zip/CPP/7zip/Compress/BZip2Crc.h

@@ -3,7 +3,7 @@
 #ifndef __BZIP2_CRC_H
 #define __BZIP2_CRC_H
 
-#include "Common/Types.h"
+#include "../../Common/MyTypes.h"
 
 class CBZip2Crc
 {