seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -3,39 +3,192 @@
 #ifndef __7Z_METHOD_PROPS_H
 #define __7Z_METHOD_PROPS_H
 
-#include "../../Common/MyVector.h"
+#include "../../Common/MyString.h"
 
 #include "../../Windows/PropVariant.h"
 
-#include "MethodId.h"
+#include "../ICoder.h"
+
+bool StringToBool(const UString &s, bool &res);
+HRESULT PROPVARIANT_to_bool(const PROPVARIANT &prop, bool &dest);
+unsigned ParseStringToUInt32(const UString &srcString, UInt32 &number);
+HRESULT ParsePropToUInt32(const UString &name, const PROPVARIANT &prop, UInt32 &resValue);
+
+HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 defaultNumThreads, UInt32 &numThreads);
 
 struct CProp
 {
   PROPID Id;
+  bool IsOptional;
   NWindows::NCOM::CPropVariant Value;
+  CProp(): IsOptional(false) {}
 };
 
-struct CMethod
+struct CProps
 {
-  CMethodId Id;
   CObjectVector<CProp> Props;
+
+  void Clear() { Props.Clear(); }
+
+  bool AreThereNonOptionalProps() const
+  {
+    FOR_VECTOR (i, Props)
+      if (!Props[i].IsOptional)
+        return true;
+    return false;
+  }
+
+  void AddProp32(PROPID propid, UInt32 level);
+
+  void AddProp_Ascii(PROPID propid, const char *s)
+  {
+    CProp &prop = Props.AddNew();
+    prop.IsOptional = true;
+    prop.Id = propid;
+    prop.Value = s;
+  }
+
+  HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const;
 };
 
-struct CMethodsMode
+class CMethodProps: public CProps
 {
-  CObjectVector<CMethod> Methods;
-  #ifndef _7ZIP_ST
-  UInt32 NumThreads;
-  #endif
-
-  CMethodsMode()
-      #ifndef _7ZIP_ST
-      : NumThreads(1)
-      #endif
-  {}
-  bool IsEmpty() const { return Methods.IsEmpty() ; }
+  HRESULT SetParam(const UString &name, const UString &value);
+public:
+  int GetLevel() const;
+  int Get_NumThreads() const
+  {
+    int i = FindProp(NCoderPropID::kNumThreads);
+    if (i >= 0)
+      if (Props[i].Value.vt == VT_UI4)
+        return (int)Props[i].Value.ulVal;
+    return -1;
+  }
+
+  bool Get_DicSize(UInt32 &res) const
+  {
+    res = 0;
+    int i = FindProp(NCoderPropID::kDictionarySize);
+    if (i >= 0)
+      if (Props[i].Value.vt == VT_UI4)
+      {
+        res = Props[i].Value.ulVal;
+        return true;
+      }
+    return false;
+  }
+
+  int FindProp(PROPID id) const;
+
+  UInt32 Get_Lzma_Algo() const
+  {
+    int i = FindProp(NCoderPropID::kAlgorithm);
+    if (i >= 0)
+      if (Props[i].Value.vt == VT_UI4)
+        return Props[i].Value.ulVal;
+    return GetLevel() >= 5 ? 1 : 0;
+  }
+
+  UInt32 Get_Lzma_DicSize() const
+  {
+    int i = FindProp(NCoderPropID::kDictionarySize);
+    if (i >= 0)
+      if (Props[i].Value.vt == VT_UI4)
+        return Props[i].Value.ulVal;
+    int level = GetLevel();
+    return level <= 5 ? (1 << (level * 2 + 14)) : (level == 6 ? (1 << 25) : (1 << 26));
+  }
+
+  bool Are_Lzma_Model_Props_Defined() const
+  {
+    if (FindProp(NCoderPropID::kPosStateBits) >= 0) return true;
+    if (FindProp(NCoderPropID::kLitContextBits) >= 0) return true;
+    if (FindProp(NCoderPropID::kLitPosBits) >= 0) return true;
+    return false;
+  }
+
+  UInt32 Get_Lzma_NumThreads(bool &fixedNumber) const
+  {
+    fixedNumber = false;
+    int numThreads = Get_NumThreads();
+    if (numThreads >= 0)
+    {
+      fixedNumber = true;
+      return numThreads < 2 ? 1 : 2;
+    }
+    return Get_Lzma_Algo() == 0 ? 1 : 2;
+  }
+
+  UInt32 Get_BZip2_NumThreads(bool &fixedNumber) const
+  {
+    fixedNumber = false;
+    int numThreads = Get_NumThreads();
+    if (numThreads >= 0)
+    {
+      fixedNumber = true;
+      if (numThreads < 1) return 1;
+      if (numThreads > 64) return 64;
+      return numThreads;
+    }
+    return 1;
+  }
+
+  UInt32 Get_BZip2_BlockSize() const
+  {
+    int i = FindProp(NCoderPropID::kDictionarySize);
+    if (i >= 0)
+      if (Props[i].Value.vt == VT_UI4)
+      {
+        UInt32 blockSize = Props[i].Value.ulVal;
+        const UInt32 kDicSizeMin = 100000;
+        const UInt32 kDicSizeMax = 900000;
+        if (blockSize < kDicSizeMin) blockSize = kDicSizeMin;
+        if (blockSize > kDicSizeMax) blockSize = kDicSizeMax;
+        return blockSize;
+      }
+    int level = GetLevel();
+    return 100000 * (level >= 5 ? 9 : (level >= 1 ? level * 2 - 1: 1));
+  }
+
+  UInt32 Get_Ppmd_MemSize() const
+  {
+    int i = FindProp(NCoderPropID::kUsedMemorySize);
+    if (i >= 0)
+      if (Props[i].Value.vt == VT_UI4)
+        return Props[i].Value.ulVal;
+    int level = GetLevel();
+    return level >= 9 ? (192 << 20) : ((UInt32)1 << (level + 19));
+  }
+
+  void AddProp_Level(UInt32 level)
+  {
+    AddProp32(NCoderPropID::kLevel, level);
+  }
+
+  void AddProp_NumThreads(UInt32 numThreads)
+  {
+    AddProp32(NCoderPropID::kNumThreads, numThreads);
+  }
+
+  HRESULT ParseParamsFromString(const UString &srcString);
+  HRESULT ParseParamsFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
 };
 
-HRESULT SetMethodProperties(const CMethod &method, const UInt64 *inSizeForReduce, IUnknown *coder);
+class COneMethodInfo: public CMethodProps
+{
+public:
+  AString MethodName;
+  UString PropsString;
+  
+  void Clear()
+  {
+    CMethodProps::Clear();
+    MethodName.Empty();
+    PropsString.Empty();
+  }
+  bool IsEmpty() const { return MethodName.IsEmpty() && Props.IsEmpty(); }
+  HRESULT ParseMethodFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
+  HRESULT ParseMethodFromString(const UString &s);
+};
 
 #endif

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

@@ -2,7 +2,8 @@
 
 #include "StdAfx.h"
 
-#include "Common/Defs.h"
+#include "../../Common/Defs.h"
+
 #include "OffsetStream.h"
 
 HRESULT COffsetOutStream::Init(IOutStream *stream, UInt64 offset)
@@ -17,14 +18,17 @@ STDMETHODIMP COffsetOutStream::Write(const void *data, UInt32 size, UInt32 *proc
   return _stream->Write(data, size, processedSize);
 }
 
-STDMETHODIMP COffsetOutStream::Seek(Int64 offset, UInt32 seekOrigin,
-    UInt64 *newPosition)
+STDMETHODIMP COffsetOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   UInt64 absoluteNewPosition;
   if (seekOrigin == STREAM_SEEK_SET)
+  {
+    if (offset < 0)
+      return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
     offset += _offset;
+  }
   HRESULT result = _stream->Seek(offset, seekOrigin, &absoluteNewPosition);
-  if (newPosition != NULL)
+  if (newPosition)
     *newPosition = absoluteNewPosition - _offset;
   return result;
 }

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

@@ -1,9 +1,10 @@
 // OffsetStream.h
 
-#ifndef __OFFSETSTREAM_H
-#define __OFFSETSTREAM_H
+#ifndef __OFFSET_STREAM_H
+#define __OFFSET_STREAM_H
+
+#include "../../Common/MyCom.h"
 
-#include "Common/MyCom.h"
 #include "../IStream.h"
 
 class COffsetOutStream:

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

@@ -6,34 +6,29 @@
 
 #include "OutBuffer.h"
 
-bool COutBuffer::Create(UInt32 bufferSize)
+bool COutBuffer::Create(UInt32 bufSize) throw()
 {
   const UInt32 kMinBlockSize = 1;
-  if (bufferSize < kMinBlockSize)
-    bufferSize = kMinBlockSize;
-  if (_buffer != 0 && _bufferSize == bufferSize)
+  if (bufSize < kMinBlockSize)
+    bufSize = kMinBlockSize;
+  if (_buf != 0 && _bufSize == bufSize)
     return true;
   Free();
-  _bufferSize = bufferSize;
-  _buffer = (Byte *)::MidAlloc(bufferSize);
-  return (_buffer != 0);
+  _bufSize = bufSize;
+  _buf = (Byte *)::MidAlloc(bufSize);
+  return (_buf != 0);
 }
 
-void COutBuffer::Free()
+void COutBuffer::Free() throw()
 {
-  ::MidFree(_buffer);
-  _buffer = 0;
+  ::MidFree(_buf);
+  _buf = 0;
 }
 
-void COutBuffer::SetStream(ISequentialOutStream *stream)
-{
-  _stream = stream;
-}
-
-void COutBuffer::Init()
+void COutBuffer::Init() throw()
 {
   _streamPos = 0;
-  _limitPos = _bufferSize;
+  _limitPos = _bufSize;
   _pos = 0;
   _processedSize = 0;
   _overDict = false;
@@ -42,27 +37,27 @@ void COutBuffer::Init()
   #endif
 }
 
-UInt64 COutBuffer::GetProcessedSize() const
+UInt64 COutBuffer::GetProcessedSize() const throw()
 {
   UInt64 res = _processedSize + _pos - _streamPos;
   if (_streamPos > _pos)
-    res += _bufferSize;
+    res += _bufSize;
   return res;
 }
 
 
-HRESULT COutBuffer::FlushPart()
+HRESULT COutBuffer::FlushPart() throw()
 {
-  // _streamPos < _bufferSize
-  UInt32 size = (_streamPos >= _pos) ? (_bufferSize - _streamPos) : (_pos - _streamPos);
+  // _streamPos < _bufSize
+  UInt32 size = (_streamPos >= _pos) ? (_bufSize - _streamPos) : (_pos - _streamPos);
   HRESULT result = S_OK;
   #ifdef _NO_EXCEPTIONS
   result = ErrorCode;
   #endif
-  if (_buffer2 != 0)
+  if (_buf2 != 0)
   {
-    memmove(_buffer2, _buffer + _streamPos, size);
-    _buffer2 += size;
+    memcpy(_buf2, _buf + _streamPos, size);
+    _buf2 += size;
   }
 
   if (_stream != 0
@@ -72,30 +67,30 @@ HRESULT COutBuffer::FlushPart()
      )
   {
     UInt32 processedSize = 0;
-    result = _stream->Write(_buffer + _streamPos, size, &processedSize);
+    result = _stream->Write(_buf + _streamPos, size, &processedSize);
     size = processedSize;
   }
   _streamPos += size;
-  if (_streamPos == _bufferSize)
+  if (_streamPos == _bufSize)
     _streamPos = 0;
-  if (_pos == _bufferSize)
+  if (_pos == _bufSize)
   {
     _overDict = true;
     _pos = 0;
   }
-  _limitPos = (_streamPos > _pos) ? _streamPos : _bufferSize;
+  _limitPos = (_streamPos > _pos) ? _streamPos : _bufSize;
   _processedSize += size;
   return result;
 }
 
-HRESULT COutBuffer::Flush()
+HRESULT COutBuffer::Flush() throw()
 {
   #ifdef _NO_EXCEPTIONS
   if (ErrorCode != S_OK)
     return ErrorCode;
   #endif
 
-  while(_streamPos != _pos)
+  while (_streamPos != _pos)
   {
     HRESULT result = FlushPart();
     if (result != S_OK)

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

@@ -1,7 +1,7 @@
 // OutBuffer.h
 
-#ifndef __OUTBUFFER_H
-#define __OUTBUFFER_H
+#ifndef __OUT_BUFFER_H
+#define __OUT_BUFFER_H
 
 #include "../IStream.h"
 #include "../../Common/MyCom.h"
@@ -17,39 +17,38 @@ struct COutBufferException: public CSystemException
 class COutBuffer
 {
 protected:
-  Byte *_buffer;
+  Byte *_buf;
   UInt32 _pos;
   UInt32 _limitPos;
   UInt32 _streamPos;
-  UInt32 _bufferSize;
-  CMyComPtr<ISequentialOutStream> _stream;
+  UInt32 _bufSize;
+  ISequentialOutStream *_stream;
   UInt64 _processedSize;
-  Byte  *_buffer2;
+  Byte  *_buf2;
   bool _overDict;
 
-  HRESULT FlushPart();
+  HRESULT FlushPart() throw();
 public:
   #ifdef _NO_EXCEPTIONS
   HRESULT ErrorCode;
   #endif
 
-  COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}
+  COutBuffer(): _buf(0), _pos(0), _stream(0), _buf2(0) {}
   ~COutBuffer() { Free(); }
   
-  bool Create(UInt32 bufferSize);
-  void Free();
+  bool Create(UInt32 bufSize) throw();
+  void Free() throw();
 
-  void SetMemStream(Byte *buffer) { _buffer2 = buffer; }
-  void SetStream(ISequentialOutStream *stream);
-  void Init();
-  HRESULT Flush();
+  void SetMemStream(Byte *buf) { _buf2 = buf; }
+  void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+  void Init() throw();
+  HRESULT Flush() throw();
   void FlushWithCheck();
-  void ReleaseStream() {  _stream.Release(); }
 
   void WriteByte(Byte b)
   {
-    _buffer[_pos++] = b;
-    if(_pos == _limitPos)
+    _buf[_pos++] = b;
+    if (_pos == _limitPos)
       FlushWithCheck();
   }
   void WriteBytes(const void *data, size_t size)
@@ -58,7 +57,7 @@ public:
       WriteByte(((const Byte *)data)[i]);
   }
 
-  UInt64 GetProcessedSize() const;
+  UInt64 GetProcessedSize() const throw();
 };
 
 #endif

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

@@ -40,15 +40,15 @@ STDMETHODIMP COutMemStream::Write(const void *data, UInt32 size, UInt32 *process
     return OutSeqStream->Write(data, size, processedSize);
   if (processedSize != 0)
     *processedSize = 0;
-  while(size != 0)
+  while (size != 0)
   {
-    if ((int)_curBlockIndex < Blocks.Blocks.Size())
+    if (_curBlockIndex < Blocks.Blocks.Size())
     {
-      Byte *p = (Byte *)Blocks.Blocks[(int)_curBlockIndex] + _curBlockPos;
+      Byte *p = (Byte *)Blocks.Blocks[_curBlockIndex] + _curBlockPos;
       size_t curSize = _memManager->GetBlockSize() - _curBlockPos;
       if (size < curSize)
         curSize = size;
-      memmove(p, data, curSize);
+      memcpy(p, data, curSize);
       if (processedSize != 0)
         *processedSize += (UInt32)curSize;
       data = (const void *)((const Byte *)data + curSize);
@@ -124,7 +124,7 @@ STDMETHODIMP COutMemStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPos
   }
   else
     return E_NOTIMPL;
-  if (newPosition != 0)
+  if (newPosition)
     *newPosition = GetPos();
   return S_OK;
 }

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

@@ -1,9 +1,10 @@
 // OutMemStream.h
 
-#ifndef __OUTMEMSTREAM_H
-#define __OUTMEMSTREAM_H
+#ifndef __OUT_MEM_STREAM_H
+#define __OUT_MEM_STREAM_H
+
+#include "../../Common/MyCom.h"
 
-#include "Common/MyCom.h"
 #include "MemBlocks.h"
 
 class COutMemStream:
@@ -11,7 +12,7 @@ class COutMemStream:
   public CMyUnknownImp
 {
   CMemBlockManagerMt *_memManager;
-  size_t _curBlockIndex;
+  unsigned _curBlockIndex;
   size_t _curBlockPos;
   bool _realStreamMode;
 

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

@@ -1,14 +1,16 @@
-// ProgressUtils.h
+// ProgressUtils.cpp
 
 #include "StdAfx.h"
 
 #include "ProgressUtils.h"
 
-CLocalProgress::CLocalProgress()
-{
-  ProgressOffset = InSize = OutSize = 0;
-  SendRatio = SendProgress = true;
-}
+CLocalProgress::CLocalProgress():
+    ProgressOffset(0),
+    InSize(0),
+    OutSize(0),
+    SendRatio(true),
+    SendProgress(true)
+  {}
 
 void CLocalProgress::Init(IProgress *progress, bool inSizeIsMain)
 {
@@ -20,19 +22,26 @@ void CLocalProgress::Init(IProgress *progress, bool inSizeIsMain)
 
 STDMETHODIMP CLocalProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
 {
-  UInt64 inSizeNew = InSize, outSizeNew = OutSize;
+  UInt64 inSize2 = InSize;
+  UInt64 outSize2 = OutSize;
+  
   if (inSize)
-    inSizeNew += (*inSize);
+    inSize2 += (*inSize);
   if (outSize)
-    outSizeNew += (*outSize);
+    outSize2 += (*outSize);
+  
   if (SendRatio && _ratioProgress)
   {
-    RINOK(_ratioProgress->SetRatioInfo(&inSizeNew, &outSizeNew));
+    RINOK(_ratioProgress->SetRatioInfo(&inSize2, &outSize2));
   }
-  inSizeNew += ProgressOffset;
-  outSizeNew += ProgressOffset;
+  
   if (SendProgress)
-    return _progress->SetCompleted(_inSizeIsMain ? &inSizeNew : &outSizeNew);
+  {
+    inSize2 += ProgressOffset;
+    outSize2 += ProgressOffset;
+    return _progress->SetCompleted(_inSizeIsMain ? &inSize2 : &outSize2);
+  }
+  
   return S_OK;
 }
 

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

@@ -1,7 +1,7 @@
 // ProgressUtils.h
 
-#ifndef __PROGRESSUTILS_H
-#define __PROGRESSUTILS_H
+#ifndef __PROGRESS_UTILS_H
+#define __PROGRESS_UTILS_H
 
 #include "../../Common/MyCom.h"
 
@@ -23,10 +23,11 @@ public:
   bool SendProgress;
 
   CLocalProgress();
+
   void Init(IProgress *progress, bool inSizeIsMain);
   HRESULT SetCur();
 
-  MY_UNKNOWN_IMP
+  MY_UNKNOWN_IMP1(ICompressProgressInfo)
 
   STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
 };

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

@@ -0,0 +1,108 @@
+// PropId.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/MyWindows.h"
+
+#include "../PropID.h"
+
+// VARTYPE
+const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED] =
+{
+  VT_EMPTY,
+  VT_UI4,
+  VT_UI4,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BOOL,
+  VT_UI8,
+  VT_UI8,
+  VT_UI4,
+  VT_FILETIME,
+  VT_FILETIME,
+  VT_FILETIME,
+  VT_BOOL,
+  VT_BOOL,
+  VT_BOOL,
+  VT_BOOL,
+  VT_BOOL,
+  VT_UI4,
+  VT_UI4,
+  VT_BSTR,
+  VT_BOOL,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BSTR,
+  VT_UI8,
+  VT_BSTR,
+  VT_UI8,
+  VT_BSTR,
+  VT_UI8,
+  VT_UI8,
+  VT_BSTR, // or VT_UI8 kpidUnpackVer
+  VT_UI4, // or VT_UI8 kpidVolume
+  VT_BOOL,
+  VT_UI8,
+  VT_UI8,
+  VT_UI8,
+  VT_UI8,
+  VT_UI4,
+  VT_BOOL,
+  VT_BOOL,
+  VT_BSTR,
+  VT_UI8,
+  VT_UI8,
+  VT_UI4, // kpidChecksum
+  VT_BSTR,
+  VT_UI8,
+  VT_BSTR, // or VT_UI8 kpidId
+  VT_BSTR,
+  VT_BSTR,
+  VT_UI4,
+  VT_UI4,
+  VT_BSTR,
+  VT_BSTR,
+  VT_UI8,
+  VT_UI8,
+  VT_UI4,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BSTR, // kpidNtSecure
+  VT_BOOL,
+  VT_BOOL,
+  VT_BOOL,
+  VT_BOOL,
+  VT_BSTR, // SHA-1
+  VT_BSTR, // SHA-256
+  VT_BSTR,
+  VT_UI8,
+  VT_UI4,
+  VT_UI4,
+  VT_BSTR,
+  VT_UI8,
+  VT_UI8,
+  VT_UI8,
+  VT_UI8,
+  VT_UI8,
+  VT_UI8,
+  VT_UI8,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BSTR,
+  VT_BOOL,
+  VT_BOOL,
+  VT_BOOL,
+  VT_UI8,
+  VT_UI8,
+  VT_BSTR, // kpidNtReparse
+  VT_BSTR,
+  VT_UI8,
+  VT_UI8,
+  VT_BOOL,
+  VT_BSTR,
+  VT_BSTR
+};