seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -5,20 +5,18 @@
 
 #include "../../Common/MyCom.h"
 #include "../../Windows/FileDir.h"
-#include "../../Windows/FileIO.h"
 
 #include "../IStream.h"
 
 class CInOutTempBuffer
 {
-  NWindows::NFile::NDirectory::CTempFile _tempFile;
+  NWindows::NFile::NDir::CTempFile _tempFile;
   NWindows::NFile::NIO::COutFile _outFile;
   Byte *_buf;
-  UInt32 _bufPos;
-  CSysString _tempFileName;
-  bool _tempFileCreated;
+  size_t _bufPos;
   UInt64 _size;
   UInt32 _crc;
+  bool _tempFileCreated;
 
   bool WriteToFile(const void *data, UInt32 size);
 public:
@@ -33,6 +31,7 @@ public:
   UInt64 GetDataSize() const { return _size; }
 };
 
+/*
 class CSequentialOutTempBufferImp:
   public ISequentialOutStream,
   public CMyUnknownImp
@@ -44,5 +43,6 @@ public:
 
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };
+*/
 
 #endif

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

@@ -2,35 +2,46 @@
 
 #include "StdAfx.h"
 
+#include <string.h>
+
 #include "LimitedStreams.h"
-#include "../../Common/Defs.h"
 
 STDMETHODIMP CLimitedSequentialInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 realProcessedSize = 0;
-  UInt32 sizeToRead = (UInt32)MyMin((_size - _pos), (UInt64)size);
+  {
+    const UInt64 rem = _size - _pos;
+    if (size > rem)
+      size = (UInt32)rem;
+  }
   HRESULT result = S_OK;
-  if (sizeToRead > 0)
+  if (size != 0)
   {
-    result = _stream->Read(data, sizeToRead, &realProcessedSize);
+    result = _stream->Read(data, size, &realProcessedSize);
     _pos += realProcessedSize;
     if (realProcessedSize == 0)
       _wasFinished = true;
   }
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = realProcessedSize;
   return result;
 }
 
 STDMETHODIMP CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
   if (_virtPos >= _size)
-    return (_virtPos == _size) ? S_OK: E_FAIL;
-  UInt64 rem = _size - _virtPos;
-  if (rem < size)
-    size = (UInt32)rem;
+  {
+    // 9.31: Fixed. Windows doesn't return error in ReadFile and IStream->Read in that case.
+    return S_OK;
+    // return (_virtPos == _size) ? S_OK: E_FAIL; // ERROR_HANDLE_EOF
+  }
+  {
+    const UInt64 rem = _size - _virtPos;
+    if (size > rem)
+      size = (UInt32)rem;
+  }
   UInt64 newPos = _startOffset + _virtPos;
   if (newPos != _physPos)
   {
@@ -38,7 +49,7 @@ STDMETHODIMP CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSi
     RINOK(SeekToPhys());
   }
   HRESULT res = _stream->Read(data, size, &size);
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = size;
   _physPos += size;
   _virtPos += size;
@@ -47,48 +58,71 @@ STDMETHODIMP CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSi
 
 STDMETHODIMP CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
-  switch(seekOrigin)
+  switch (seekOrigin)
   {
-    case STREAM_SEEK_SET: _virtPos = offset; break;
-    case STREAM_SEEK_CUR: _virtPos += offset; break;
-    case STREAM_SEEK_END: _virtPos = _size + offset; break;
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _virtPos; break;
+    case STREAM_SEEK_END: offset += _size; break;
     default: return STG_E_INVALIDFUNCTION;
   }
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _virtPos = offset;
   if (newPosition)
     *newPosition = _virtPos;
   return S_OK;
 }
 
+HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream)
+{
+  *resStream = 0;
+  CLimitedInStream *streamSpec = new CLimitedInStream;
+  CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+  streamSpec->SetStream(inStream);
+  RINOK(streamSpec->InitAndSeek(pos, size));
+  streamSpec->SeekToStart();
+  *resStream = streamTemp.Detach();
+  return S_OK;
+}
+
 STDMETHODIMP CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
   if (_virtPos >= Size)
-    return (_virtPos == Size) ? S_OK: E_FAIL;
+    return S_OK;
+  {
+    UInt64 rem = Size - _virtPos;
+    if (size > rem)
+      size = (UInt32)rem;
+  }
+  if (size == 0)
+    return S_OK;
 
   if (_curRem == 0)
   {
-    UInt32 blockSize = (UInt32)1 << BlockSizeLog;
-    UInt32 virtBlock = (UInt32)(_virtPos >> BlockSizeLog);
-    UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
-    UInt32 phyBlock = Vector[virtBlock];
+    const UInt32 blockSize = (UInt32)1 << BlockSizeLog;
+    const UInt32 virtBlock = (UInt32)(_virtPos >> BlockSizeLog);
+    const UInt32 offsetInBlock = (UInt32)_virtPos & (blockSize - 1);
+    const UInt32 phyBlock = Vector[virtBlock];
+    
     UInt64 newPos = StartOffset + ((UInt64)phyBlock << BlockSizeLog) + offsetInBlock;
     if (newPos != _physPos)
     {
       _physPos = newPos;
       RINOK(SeekToPhys());
     }
+
     _curRem = blockSize - offsetInBlock;
+    
     for (int i = 1; i < 64 && (virtBlock + i) < (UInt32)Vector.Size() && phyBlock + i == Vector[virtBlock + i]; i++)
       _curRem += (UInt32)1 << BlockSizeLog;
-    UInt64 rem = Size - _virtPos;
-    if (_curRem > rem)
-      _curRem = (UInt32)rem;
   }
+  
   if (size > _curRem)
     size = _curRem;
   HRESULT res = Stream->Read(data, size, &size);
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = size;
   _physPos += size;
   _virtPos += size;
@@ -98,39 +132,88 @@ STDMETHODIMP CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSi
  
 STDMETHODIMP CClusterInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
-  UInt64 newVirtPos = offset;
-  switch(seekOrigin)
+  switch (seekOrigin)
   {
     case STREAM_SEEK_SET: break;
-    case STREAM_SEEK_CUR: newVirtPos += _virtPos; break;
-    case STREAM_SEEK_END: newVirtPos += Size; break;
+    case STREAM_SEEK_CUR: offset += _virtPos; break;
+    case STREAM_SEEK_END: offset += Size; break;
     default: return STG_E_INVALIDFUNCTION;
   }
-  if (_virtPos != newVirtPos)
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  if (_virtPos != (UInt64)offset)
     _curRem = 0;
-  _virtPos = newVirtPos;
+  _virtPos = offset;
   if (newPosition)
-    *newPosition = newVirtPos;
+    *newPosition = offset;
   return S_OK;
 }
 
 
-HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream)
+STDMETHODIMP CExtentsStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
-  *resStream = 0;
-  CLimitedInStream *streamSpec = new CLimitedInStream;
-  CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
-  streamSpec->SetStream(inStream);
-  RINOK(streamSpec->InitAndSeek(pos, size));
-  streamSpec->SeekToStart();
-  *resStream = streamTemp.Detach();
+  if (processedSize)
+    *processedSize = 0;
+  if (_virtPos >= Extents.Back().Virt)
+    return S_OK;
+  if (size == 0)
+    return S_OK;
+  
+  unsigned left = 0, right = Extents.Size() - 1;
+  for (;;)
+  {
+    unsigned mid = (left + right) / 2;
+    if (mid == left)
+      break;
+    if (_virtPos < Extents[mid].Virt)
+      right = mid;
+    else
+      left = mid;
+  }
+  
+  const CSeekExtent &extent = Extents[left];
+  UInt64 phyPos = extent.Phy + (_virtPos - extent.Virt);
+  if (_needStartSeek || _phyPos != phyPos)
+  {
+    _needStartSeek = false;
+    _phyPos = phyPos;
+    RINOK(SeekToPhys());
+  }
+  
+  UInt64 rem = Extents[left + 1].Virt - _virtPos;
+  if (size > rem)
+    size = (UInt32)rem;
+  
+  HRESULT res = Stream->Read(data, size, &size);
+  _phyPos += size;
+  _virtPos += size;
+  if (processedSize)
+    *processedSize = size;
+  return res;
+}
+
+STDMETHODIMP CExtentsStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  switch (seekOrigin)
+  {
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _virtPos; break;
+    case STREAM_SEEK_END: offset += Extents.Back().Virt; break;
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _virtPos = offset;
+  if (newPosition)
+    *newPosition = _virtPos;
   return S_OK;
 }
 
+
 STDMETHODIMP CLimitedSequentialOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   HRESULT result = S_OK;
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
   if (size > _size)
   {
@@ -139,7 +222,7 @@ STDMETHODIMP CLimitedSequentialOutStream::Write(const void *data, UInt32 size, U
       _overflow = true;
       if (!_overflowIsAllowed)
         return E_FAIL;
-      if (processedSize != NULL)
+      if (processedSize)
         *processedSize = size;
       return S_OK;
     }
@@ -148,7 +231,137 @@ STDMETHODIMP CLimitedSequentialOutStream::Write(const void *data, UInt32 size, U
   if (_stream)
     result = _stream->Write(data, size, &size);
   _size -= size;
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = size;
   return result;
 }
+
+
+STDMETHODIMP CTailInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 cur;
+  HRESULT res = Stream->Read(data, size, &cur);
+  if (processedSize)
+    *processedSize = cur;
+  _virtPos += cur;
+  return res;
+}
+  
+STDMETHODIMP CTailInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  switch (seekOrigin)
+  {
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _virtPos; break;
+    case STREAM_SEEK_END:
+    {
+      UInt64 pos = 0;
+      RINOK(Stream->Seek(offset, STREAM_SEEK_END, &pos));
+      if (pos < Offset)
+        return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+      _virtPos = pos - Offset;
+      if (newPosition)
+        *newPosition = _virtPos;
+      return S_OK;
+    }
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _virtPos = offset;
+  if (newPosition)
+    *newPosition = _virtPos;
+  return Stream->Seek(Offset + _virtPos, STREAM_SEEK_SET, NULL);
+}
+
+STDMETHODIMP CLimitedCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  if (_virtPos >= _size)
+  {
+    // 9.31: Fixed. Windows doesn't return error in ReadFile and IStream->Read in that case.
+    return S_OK;
+    // return (_virtPos == _size) ? S_OK: E_FAIL; // ERROR_HANDLE_EOF
+  }
+  UInt64 rem = _size - _virtPos;
+  if (rem < size)
+    size = (UInt32)rem;
+
+  UInt64 newPos = _startOffset + _virtPos;
+  UInt64 offsetInCache = newPos - _cachePhyPos;
+  HRESULT res = S_OK;
+  if (newPos >= _cachePhyPos &&
+      offsetInCache <= _cacheSize &&
+      size <= _cacheSize - (size_t)offsetInCache)
+  {
+    if (size != 0)
+      memcpy(data, _cache + (size_t)offsetInCache, size);
+  }
+  else
+  {
+    if (newPos != _physPos)
+    {
+      _physPos = newPos;
+      RINOK(SeekToPhys());
+    }
+    res = _stream->Read(data, size, &size);
+    _physPos += size;
+  }
+  if (processedSize)
+    *processedSize = size;
+  _virtPos += size;
+  return res;
+}
+
+STDMETHODIMP CLimitedCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  switch (seekOrigin)
+  {
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _virtPos; break;
+    case STREAM_SEEK_END: offset += _size; break;
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _virtPos = offset;
+  if (newPosition)
+    *newPosition = _virtPos;
+  return S_OK;
+}
+
+STDMETHODIMP CTailOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  UInt32 cur;
+  HRESULT res = Stream->Write(data, size, &cur);
+  if (processedSize)
+    *processedSize = cur;
+  _virtPos += cur;
+  if (_virtSize < _virtPos)
+    _virtSize = _virtPos;
+  return res;
+}
+  
+STDMETHODIMP CTailOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  switch (seekOrigin)
+  {
+    case STREAM_SEEK_SET: break;
+    case STREAM_SEEK_CUR: offset += _virtPos; break;
+    case STREAM_SEEK_END: offset += _virtSize; break;
+    default: return STG_E_INVALIDFUNCTION;
+  }
+  if (offset < 0)
+    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+  _virtPos = offset;
+  if (newPosition)
+    *newPosition = _virtPos;
+  return Stream->Seek(Offset + _virtPos, STREAM_SEEK_SET, NULL);
+}
+
+STDMETHODIMP CTailOutStream::SetSize(UInt64 newSize)
+{
+  _virtSize = newSize;
+  return Stream->SetSize(Offset + newSize);
+}

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

@@ -3,6 +3,7 @@
 #ifndef __LIMITED_STREAMS_H
 #define __LIMITED_STREAMS_H
 
+#include "../../Common/MyBuffer.h"
 #include "../../Common/MyCom.h"
 #include "../../Common/MyVector.h"
 #include "../IStream.h"
@@ -25,10 +26,11 @@ public:
     _wasFinished = false;
   }
  
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP1(ISequentialInStream)
 
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
   UInt64 GetSize() const { return _pos; }
+  UInt64 GetRem() const { return _size - _pos; }
   bool WasFinished() const { return _wasFinished; }
 };
 
@@ -54,7 +56,7 @@ public:
     return SeekToPhys();
   }
  
-  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);
@@ -62,6 +64,8 @@ public:
   HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
 };
 
+HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream);
+
 class CClusterInStream:
   public IInStream,
   public CMyUnknownImp
@@ -70,11 +74,11 @@ class CClusterInStream:
   UInt64 _physPos;
   UInt32 _curRem;
 public:
-  CMyComPtr<IInStream> Stream;
-  UInt64 StartOffset;
+  unsigned BlockSizeLog;
   UInt64 Size;
-  int BlockSizeLog;
+  CMyComPtr<IInStream> Stream;
   CRecordVector<UInt32> Vector;
+  UInt64 StartOffset;
 
   HRESULT SeekToPhys() { return Stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
 
@@ -91,13 +95,44 @@ public:
     return S_OK;
   }
 
-  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);
 };
 
-HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream);
+struct CSeekExtent
+{
+  UInt64 Phy;
+  UInt64 Virt;
+};
+
+class CExtentsStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  UInt64 _phyPos;
+  UInt64 _virtPos;
+  bool _needStartSeek;
+
+  HRESULT SeekToPhys() { return Stream->Seek(_phyPos, STREAM_SEEK_SET, NULL); }
+
+public:
+  CMyComPtr<IInStream> Stream;
+  CRecordVector<CSeekExtent> Extents;
+
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+  void ReleaseStream() { Stream.Release(); }
+
+  void Init()
+  {
+    _virtPos = 0;
+    _phyPos = 0;
+    _needStartSeek = true;
+  }
+};
 
 class CLimitedSequentialOutStream:
   public ISequentialOutStream,
@@ -108,7 +143,7 @@ class CLimitedSequentialOutStream:
   bool _overflow;
   bool _overflowIsAllowed;
 public:
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   void SetStream(ISequentialOutStream *stream) { _stream = stream; }
   void ReleaseStream() { _stream.Release(); }
@@ -122,4 +157,96 @@ public:
   UInt64 GetRem() const { return _size; }
 };
 
+
+class CTailInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  UInt64 _virtPos;
+public:
+  CMyComPtr<IInStream> Stream;
+  UInt64 Offset;
+
+  void Init()
+  {
+    _virtPos = 0;
+  }
+ 
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+
+  HRESULT SeekToStart() { return Stream->Seek(Offset, STREAM_SEEK_SET, NULL); }
+};
+
+class CLimitedCachedInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<IInStream> _stream;
+  UInt64 _virtPos;
+  UInt64 _physPos;
+  UInt64 _size;
+  UInt64 _startOffset;
+  
+  const Byte *_cache;
+  size_t _cacheSize;
+  size_t _cachePhyPos;
+
+
+  HRESULT SeekToPhys() { return _stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
+public:
+  CByteBuffer Buffer;
+
+  void SetStream(IInStream *stream) { _stream = stream; }
+  void SetCache(size_t cacheSize, size_t cachePos)
+  {
+    _cache = Buffer;
+    _cacheSize = cacheSize;
+    _cachePhyPos = cachePos;
+  }
+
+  HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
+  {
+    _startOffset = startOffset;
+    _physPos = startOffset;
+    _virtPos = 0;
+    _size = size;
+    return SeekToPhys();
+  }
+ 
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+
+  HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
+};
+
+class CTailOutStream:
+  public IOutStream,
+  public CMyUnknownImp
+{
+  UInt64 _virtPos;
+  UInt64 _virtSize;
+public:
+  CMyComPtr<IOutStream> Stream;
+  UInt64 Offset;
+  
+  virtual ~CTailOutStream() {}
+
+  MY_UNKNOWN_IMP2(ISequentialOutStream, IOutStream)
+
+  void Init()
+  {
+    _virtPos = 0;
+    _virtSize = 0;
+  }
+
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+  STDMETHOD(SetSize)(UInt64 newSize);
+};
+
 #endif

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

@@ -51,7 +51,7 @@ void CMemBlockManager::FreeBlock(void *p)
 }
 
 
-HRes CMemBlockManagerMt::AllocateSpace(NWindows::NSynchronization::CSynchro *sync,size_t numBlocks, size_t numNoLockBlocks)
+HRes CMemBlockManagerMt::AllocateSpace(NWindows::NSynchronization::CSynchro *sync ,size_t numBlocks, size_t numNoLockBlocks)
 {
   if (numNoLockBlocks > numBlocks)
     return E_INVALIDARG;
@@ -62,7 +62,7 @@ HRes CMemBlockManagerMt::AllocateSpace(NWindows::NSynchronization::CSynchro *syn
   return Semaphore.Create(sync,(LONG)numLockBlocks, (LONG)numLockBlocks);
 }
 
-HRes CMemBlockManagerMt::AllocateSpaceAlways(NWindows::NSynchronization::CSynchro *sync,size_t desiredNumberOfBlocks, size_t numNoLockBlocks)
+HRes CMemBlockManagerMt::AllocateSpaceAlways(NWindows::NSynchronization::CSynchro *sync, size_t desiredNumberOfBlocks, size_t numNoLockBlocks)
 {
   if (numNoLockBlocks > desiredNumberOfBlocks)
     return E_INVALIDARG;
@@ -103,7 +103,7 @@ void CMemBlockManagerMt::FreeBlock(void *p, bool lockMode)
 
 void CMemBlocks::Free(CMemBlockManagerMt *manager)
 {
-  while(Blocks.Size() > 0)
+  while (Blocks.Size() > 0)
   {
     manager->FreeBlock(Blocks.Back());
     Blocks.DeleteBack();
@@ -120,7 +120,7 @@ void CMemBlocks::FreeOpt(CMemBlockManagerMt *manager)
 HRESULT CMemBlocks::WriteToStream(size_t blockSize, ISequentialOutStream *outStream) const
 {
   UInt64 totalSize = TotalSize;
-  for (int blockIndex = 0; totalSize > 0; blockIndex++)
+  for (unsigned blockIndex = 0; totalSize > 0; blockIndex++)
   {
     UInt32 curSize = (UInt32)blockSize;
     if (totalSize < curSize)
@@ -169,7 +169,7 @@ void CMemLockBlocks::Detach(CMemLockBlocks &blocks, CMemBlockManagerMt *memManag
   blocks.LockMode = LockMode;
   UInt64 totalSize = 0;
   size_t blockSize = memManager->GetBlockSize();
-  for (int i = 0; i < Blocks.Size(); i++)
+  FOR_VECTOR (i, Blocks)
   {
     if (totalSize < TotalSize)
       blocks.Blocks.Add(Blocks[i]);

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

@@ -3,9 +3,9 @@
 #ifndef __MEM_BLOCKS_H
 #define __MEM_BLOCKS_H
 
-#include "Common/MyVector.h"
+#include "../../Common/MyVector.h"
 
-#include "Windows/Synchronization.h"
+#include "../../Windows/Synchronization.h"
 
 #include "../IStream.h"
 
@@ -35,7 +35,7 @@ public:
   CMemBlockManagerMt(size_t blockSize = (1 << 20)): CMemBlockManager(blockSize) {}
   ~CMemBlockManagerMt() { FreeSpace(); }
 
-  HRes AllocateSpace(NWindows::NSynchronization::CSynchro *sync, size_t numBlocks, size_t numNoLockBlocks = 0);
+  HRes AllocateSpace(NWindows::NSynchronization::CSynchro *sync ,size_t numBlocks, size_t numNoLockBlocks = 0);
   HRes AllocateSpaceAlways(NWindows::NSynchronization::CSynchro *sync, size_t desiredNumberOfBlocks, size_t numNoLockBlocks = 0);
   void FreeSpace();
   void *AllocateBlock();