18.03

CPP/7zip/Archive/7z/7zCompressionMode.h

@@ -13,7 +13,9 @@ struct CMethodFull: public CMethodProps
 {
   CMethodId Id;
   UInt32 NumStreams;
+  int CodecIndex;
 
+  CMethodFull(): CodecIndex(-1) {}
   bool IsSimpleCoder() const { return NumStreams == 1; }
 };
 

CPP/7zip/Archive/7z/7zDecode.cpp

@@ -236,8 +236,8 @@ HRESULT CDecoder::Decode(
     
     _7Z_DECODER_CRYPRO_VARS_DECL
 
-    #if !defined(_7ZIP_ST) && !defined(_SFX)
-    , bool mtMode, UInt32 numThreads
+    #if !defined(_7ZIP_ST)
+    , bool mtMode, UInt32 numThreads, UInt64 memUsage
     #endif
     )
 {
@@ -312,7 +312,7 @@ HRESULT CDecoder::Decode(
       #endif
   
       CCreatedCoder cod;
-      RINOK(CreateCoder(
+      RINOK(CreateCoder_Id(
           EXTERNAL_CODECS_LOC_VARS
           coderInfo.MethodID, false, cod));
     
@@ -355,11 +355,39 @@ HRESULT CDecoder::Decode(
 
   unsigned i;
 
+  bool mt_wasUsed = false;
+
   for (i = 0; i < folderInfo.Coders.Size(); i++)
   {
     const CCoderInfo &coderInfo = folderInfo.Coders[i];
     IUnknown *decoder = _mixer->GetCoder(i).GetUnknown();
 
+    #if !defined(_7ZIP_ST)
+    if (!mt_wasUsed)
+    {
+      if (mtMode)
+      {
+        CMyComPtr<ICompressSetCoderMt> setCoderMt;
+        decoder->QueryInterface(IID_ICompressSetCoderMt, (void **)&setCoderMt);
+        if (setCoderMt)
+        {
+          mt_wasUsed = true;
+          RINOK(setCoderMt->SetNumberOfThreads(numThreads));
+        }
+      }
+      // if (memUsage != 0)
+      {
+        CMyComPtr<ICompressSetMemLimit> setMemLimit;
+        decoder->QueryInterface(IID_ICompressSetMemLimit, (void **)&setMemLimit);
+        if (setMemLimit)
+        {
+          mt_wasUsed = true;
+          RINOK(setMemLimit->SetMemLimit(memUsage));
+        }
+      }
+    }
+    #endif
+
     {
       CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties;
       decoder->QueryInterface(IID_ICompressSetDecoderProperties2, (void **)&setDecoderProperties);
@@ -376,18 +404,6 @@ HRESULT CDecoder::Decode(
       }
     }
 
-    #if !defined(_7ZIP_ST) && !defined(_SFX)
-    if (mtMode)
-    {
-      CMyComPtr<ICompressSetCoderMt> setCoderMt;
-      decoder->QueryInterface(IID_ICompressSetCoderMt, (void **)&setCoderMt);
-      if (setCoderMt)
-      {
-        RINOK(setCoderMt->SetNumberOfThreads(numThreads));
-      }
-    }
-    #endif
-
     #ifndef _NO_CRYPTO
     {
       CMyComPtr<ICryptoSetPassword> cryptoSetPassword;

CPP/7zip/Archive/7z/7zDecode.h

@@ -59,8 +59,8 @@ public:
       
       _7Z_DECODER_CRYPRO_VARS_DECL
       
-      #if !defined(_7ZIP_ST) && !defined(_SFX)
-      , bool mtMode, UInt32 numThreads
+      #if !defined(_7ZIP_ST)
+      , bool mtMode, UInt32 numThreads, UInt64 memUsage
       #endif
       );
 };

CPP/7zip/Archive/7z/7zEncode.cpp

@@ -154,9 +154,18 @@ HRESULT CEncoder::CreateMixerCoder(
 
     CCreatedCoder cod;
     
-    RINOK(CreateCoder(
+    if (methodFull.CodecIndex >= 0)
+    {
+      RINOK(CreateCoder_Index(
+        EXTERNAL_CODECS_LOC_VARS
+        methodFull.CodecIndex, true, cod));
+    }
+    else
+    {
+      RINOK(CreateCoder_Id(
         EXTERNAL_CODECS_LOC_VARS
         methodFull.Id, true, cod));
+    }
 
     if (cod.NumStreams != methodFull.NumStreams)
       return E_FAIL;

CPP/7zip/Archive/7z/7zExtract.cpp

@@ -152,6 +152,12 @@ STDMETHODIMP CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *proc
     if (_fileIsOpen)
     {
       UInt32 cur = (size < _rem ? size : (UInt32)_rem);
+      if (_calcCrc)
+      {
+        const UInt32 k_Step = (UInt32)1 << 20;
+        if (cur > k_Step)
+          cur = k_Step;
+      }
       HRESULT result = S_OK;
       if (_stream)
         result = _stream->Write(data, cur, &cur);
@@ -363,8 +369,8 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           , dataAfterEnd_Error
           
           _7Z_DECODER_CRYPRO_VARS
-          #if !defined(_7ZIP_ST) && !defined(_SFX)
-            , true, _numThreads
+          #if !defined(_7ZIP_ST)
+            , true, _numThreads, _memUsage
           #endif
           );
 

CPP/7zip/Archive/7z/7zHandler.cpp

@@ -40,7 +40,6 @@ CHandler::CHandler()
   _crcSize = 4;
   
   #ifdef __7Z_SET_PROPERTIES
-  _numThreads = NSystem::GetNumberOfProcessors();
   _useMultiThreadMixer = true;
   #endif
   
@@ -714,8 +713,8 @@ STDMETHODIMP CHandler::Close()
 STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
 {
   COM_TRY_BEGIN
-  const UInt32 numProcessors = NSystem::GetNumberOfProcessors();
-  _numThreads = numProcessors;
+  
+  InitCommon();
   _useMultiThreadMixer = true;
 
   for (UInt32 i = 0; i < numProps; i++)
@@ -734,13 +733,15 @@ STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
         RINOK(PROPVARIANT_to_bool(value, _useMultiThreadMixer));
         continue;
       }
-      if (name.IsPrefixedBy_Ascii_NoCase("mt"))
       {
-        RINOK(ParseMtProp(name.Ptr(2), value, numProcessors, _numThreads));
-        continue;
+        HRESULT hres;
+        if (SetCommonProperty(name, value, hres))
+        {
+          RINOK(hres);
+          continue;
+        }
       }
-      else
-        return E_INVALIDARG;
+      return E_INVALIDARG;
     }
   }
   return S_OK;

CPP/7zip/Archive/7z/7zHandler.h

@@ -8,16 +8,6 @@
 
 #include "../../Common/CreateCoder.h"
 
-#ifndef EXTRACT_ONLY
-#include "../Common/HandlerOut.h"
-#endif
-
-#include "7zCompressionMode.h"
-#include "7zIn.h"
-
-namespace NArchive {
-namespace N7z {
-
 #ifndef __7Z_SET_PROPERTIES
 
 #ifdef EXTRACT_ONLY
@@ -30,6 +20,16 @@ namespace N7z {
 
 #endif
 
+// #ifdef __7Z_SET_PROPERTIES
+#include "../Common/HandlerOut.h"
+// #endif
+
+#include "7zCompressionMode.h"
+#include "7zIn.h"
+
+namespace NArchive {
+namespace N7z {
+
 
 #ifndef EXTRACT_ONLY
 
@@ -38,8 +38,6 @@ class COutHandler: public CMultiMethodProps
   HRESULT SetSolidFromString(const UString &s);
   HRESULT SetSolidFromPROPVARIANT(const PROPVARIANT &value);
 public:
-  bool _removeSfxBlock;
-  
   UInt64 _numSolidFiles;
   UInt64 _numSolidBytes;
   bool _numSolidBytesDefined;
@@ -58,6 +56,8 @@ public:
 
   bool _useMultiThreadMixer;
 
+  bool _removeSfxBlock;
+  
   // bool _volumeMode;
 
   void InitSolidFiles() { _numSolidFiles = (UInt64)(Int64)(-1); }
@@ -70,9 +70,10 @@ public:
     _numSolidBytesDefined = false;
   }
 
+  void InitProps7z();
   void InitProps();
 
-  COutHandler() { InitProps(); }
+  COutHandler() { InitProps7z(); }
 
   HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
 };
@@ -82,16 +83,23 @@ public:
 class CHandler:
   public IInArchive,
   public IArchiveGetRawProps,
+  
   #ifdef __7Z_SET_PROPERTIES
   public ISetProperties,
   #endif
+  
   #ifndef EXTRACT_ONLY
   public IOutArchive,
   #endif
+  
   PUBLIC_ISetCompressCodecsInfo
-  public CMyUnknownImp
+  
+  public CMyUnknownImp,
+
   #ifndef EXTRACT_ONLY
-  , public COutHandler
+    public COutHandler
+  #else
+    public CCommonMethodProps
   #endif
 {
 public:
@@ -135,7 +143,6 @@ private:
   #ifdef EXTRACT_ONLY
   
   #ifdef __7Z_SET_PROPERTIES
-  UInt32 _numThreads;
   bool _useMultiThreadMixer;
   #endif
 

CPP/7zip/Archive/7z/7zHandlerOut.cpp

@@ -13,6 +13,8 @@
 #include "7zOut.h"
 #include "7zUpdate.h"
 
+#ifndef EXTRACT_ONLY
+
 using namespace NWindows;
 
 namespace NArchive {
@@ -41,9 +43,11 @@ STDMETHODIMP CHandler::GetFileTimeType(UInt32 *type)
 
 HRESULT CHandler::PropsMethod_To_FullMethod(CMethodFull &dest, const COneMethodInfo &m)
 {
-  if (!FindMethod(
+  dest.CodecIndex = FindMethod_Index(
       EXTERNAL_CODECS_VARS
-      m.MethodName, dest.Id, dest.NumStreams))
+      m.MethodName, true,
+      dest.Id, dest.NumStreams);
+  if (dest.CodecIndex < 0)
     return E_INVALIDARG;
   (CProps &)dest = (CProps &)m;
   return S_OK;
@@ -699,10 +703,8 @@ static HRESULT ParseBond(UString &srcString, UInt32 &coder, UInt32 &stream)
   return S_OK;
 }
 
-void COutHandler::InitProps()
+void COutHandler::InitProps7z()
 {
-  CMultiMethodProps::Init();
-
   _removeSfxBlock = false;
   _compressHeaders = true;
   _encryptHeadersSpecified = false;
@@ -722,6 +724,14 @@ void COutHandler::InitProps()
   _useTypeSorting = false;
 }
 
+void COutHandler::InitProps()
+{
+  CMultiMethodProps::Init();
+  InitProps7z();
+}
+
+
+
 HRESULT COutHandler::SetSolidFromString(const UString &s)
 {
   UString s2 = s;
@@ -762,6 +772,10 @@ HRESULT COutHandler::SetSolidFromString(const UString &s)
       }
       _numSolidBytes = (v << numBits);
       _numSolidBytesDefined = true;
+      /*
+      if (_numSolidBytes == 0)
+        _numSolidFiles = 1;
+      */
     }
   }
   return S_OK;
@@ -810,7 +824,7 @@ HRESULT COutHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &val
       return E_INVALIDARG;
     return SetSolidFromString(name);
   }
-  
+
   UInt32 number;
   int index = ParseStringToUInt32(name, number);
   // UString realName = name.Ptr(index);
@@ -921,3 +935,5 @@ STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
 }
 
 }}
+
+#endif

CPP/7zip/Archive/7z/7zIn.cpp

@@ -1115,11 +1115,11 @@ HRESULT CInArchive::ReadAndDecodePackedStreams(
         , dataAfterEnd_Error
         
         _7Z_DECODER_CRYPRO_VARS
-        #if !defined(_7ZIP_ST) && !defined(_SFX)
+        #if !defined(_7ZIP_ST)
           , false // mtMode
           , 1     // numThreads
+          , 0     // memUsage
         #endif
-
       );
     
     RINOK(result);

CPP/7zip/Archive/7z/7zUpdate.cpp

@@ -1507,7 +1507,8 @@ void CThreadDecoder::Execute()
 
       _7Z_DECODER_CRYPRO_VARS
       #ifndef _7ZIP_ST
-        , MtMode, NumThreads
+        , MtMode, NumThreads,
+        0 // MemUsage
       #endif
 
       );
@@ -1696,13 +1697,14 @@ HRESULT Update(
 
   UInt64 inSizeForReduce = 0;
   {
+    bool isSolid = (numSolidFiles > 1 && options.NumSolidBytes != 0);
     FOR_VECTOR (i, updateItems)
     {
       const CUpdateItem &ui = updateItems[i];
       if (ui.NewData)
       {
         complexity += ui.Size;
-        if (numSolidFiles != 1)
+        if (isSolid)
           inSizeForReduce += ui.Size;
         else if (inSizeForReduce < ui.Size)
           inSizeForReduce = ui.Size;
@@ -2142,8 +2144,8 @@ HRESULT Update(
                   #ifndef _7ZIP_ST
                     , false // mtMode
                     , 1 // numThreads
+                    , 0 // memUsage
                   #endif
-
                 );
           
               RINOK(res);
@@ -2293,7 +2295,8 @@ HRESULT Update(
       continue;
     CRecordVector<CRefItem> refItems;
     refItems.ClearAndSetSize(numFiles);
-    bool sortByType = (options.UseTypeSorting && numSolidFiles > 1);
+    // bool sortByType = (options.UseTypeSorting && isSoid); // numSolidFiles > 1
+    bool sortByType = options.UseTypeSorting;
     
     unsigned i;
 

CPP/7zip/Archive/Common/HandlerOut.cpp

@@ -2,18 +2,92 @@
 
 #include "StdAfx.h"
 
-#ifndef _7ZIP_ST
-#include "../../../Windows/System.h"
-#endif
+#include "../../../Common/StringToInt.h"
 
 #include "../Common/ParseProperties.h"
 
 #include "HandlerOut.h"
 
-using namespace NWindows;
-
 namespace NArchive {
 
+bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsBase, UInt64 &res)
+{
+  if (*s == 0)
+  {
+    switch (prop.vt)
+    {
+      case VT_UI4: res = prop.ulVal; return true;
+      case VT_UI8: res = prop.uhVal.QuadPart; return true;
+      case VT_BSTR:
+        s = prop.bstrVal;
+        break;
+      default: return false;
+    }
+  }
+  else if (prop.vt != VT_EMPTY)
+    return false;
+
+  const wchar_t *end;
+  UInt64 v = ConvertStringToUInt64(s, &end);
+  if (s == end)
+    return false;
+  wchar_t c = *end;
+  if (c == 0)
+  {
+    res = v;
+    return true;
+  }
+  if (end[1] != 0)
+    return false;
+
+  if (c == '%')
+  {
+    res = percentsBase / 100 * v;
+    return true;
+  }
+
+  unsigned numBits;
+  switch (MyCharLower_Ascii(c))
+  {
+    case 'b': numBits =  0; break;
+    case 'k': numBits = 10; break;
+    case 'm': numBits = 20; break;
+    case 'g': numBits = 30; break;
+    case 't': numBits = 40; break;
+    default: return false;
+  }
+  UInt64 val2 = v << numBits;
+  if ((val2 >> numBits) != v)
+    return false;
+  res = val2;
+  return true;
+}
+
+bool CCommonMethodProps::SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres)
+{
+  hres = S_OK;
+
+  if (name.IsPrefixedBy_Ascii_NoCase("mt"))
+  {
+    #ifndef _7ZIP_ST
+    hres = ParseMtProp(name.Ptr(2), value, _numProcessors, _numThreads);
+    #endif
+    return true;
+  }
+  
+  if (name.IsPrefixedBy_Ascii_NoCase("memuse"))
+  {
+    if (!ParseSizeString(name.Ptr(6), value, _memAvail, _memUsage))
+      hres = E_INVALIDARG;
+    return true;
+  }
+
+  return false;
+}
+
+
+#ifndef EXTRACT_ONLY
+
 static void SetMethodProp32(COneMethodInfo &m, PROPID propID, UInt32 value)
 {
   if (m.FindProp(propID) < 0)
@@ -34,21 +108,23 @@ void CMultiMethodProps::SetMethodThreadsTo(COneMethodInfo &oneMethodInfo, UInt32
 }
 #endif
 
-void CMultiMethodProps::Init()
+void CMultiMethodProps::InitMulti()
 {
-  #ifndef _7ZIP_ST
-  _numProcessors = _numThreads = NSystem::GetNumberOfProcessors();
-  #endif
-  
   _level = (UInt32)(Int32)-1;
   _analysisLevel = -1;
-
-  _autoFilter = true;
   _crcSize = 4;
-  _filterMethod.Clear();
-  _methods.Clear();
+  _autoFilter = true;
 }
 
+void CMultiMethodProps::Init()
+{
+  InitCommon();
+  InitMulti();
+  _methods.Clear();
+  _filterMethod.Clear();
+}
+
+
 HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
 {
   UString name = nameSpec;
@@ -78,20 +154,18 @@ HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIAN
     _crcSize = 4;
     return ParsePropToUInt32(name, value, _crcSize);
   }
+
+  {
+    HRESULT hres;
+    if (SetCommonProperty(name, value, hres))
+      return hres;
+  }
   
   UInt32 number;
   unsigned index = ParseStringToUInt32(name, number);
   UString realName = name.Ptr(index);
   if (index == 0)
   {
-    if (name.IsPrefixedBy_Ascii_NoCase("mt"))
-    {
-      #ifndef _7ZIP_ST
-      RINOK(ParseMtProp(name.Ptr(2), value, _numProcessors, _numThreads));
-      #endif
-      
-      return S_OK;
-    }
     if (name.IsEqualTo("f"))
     {
       HRESULT res = PROPVARIANT_to_bool(value, _autoFilter);
@@ -110,20 +184,20 @@ HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIAN
   return _methods[number].ParseMethodFromPROPVARIANT(realName, value);
 }
 
+
+
 void CSingleMethodProps::Init()
 {
+  InitCommon();
+  InitSingle();
   Clear();
-  _level = (UInt32)(Int32)-1;
-  
-  #ifndef _7ZIP_ST
-  _numProcessors = _numThreads = NWindows::NSystem::GetNumberOfProcessors();
-  AddProp_NumThreads(_numThreads);
-  #endif
 }
 
+
 HRESULT CSingleMethodProps::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
 {
   Init();
+  
   for (UInt32 i = 0; i < numProps; i++)
   {
     UString name = names[i];
@@ -137,20 +211,22 @@ HRESULT CSingleMethodProps::SetProperties(const wchar_t * const *names, const PR
       RINOK(ParsePropToUInt32(name.Ptr(1), value, a));
       _level = a;
       AddProp_Level(a);
+      continue;
     }
-    else if (name.IsPrefixedBy_Ascii_NoCase("mt"))
     {
-      #ifndef _7ZIP_ST
-      RINOK(ParseMtProp(name.Ptr(2), value, _numProcessors, _numThreads));
-      AddProp_NumThreads(_numThreads);
-      #endif
-    }
-    else
-    {
-      RINOK(ParseMethodFromPROPVARIANT(names[i], value));
+      HRESULT hres;
+      if (SetCommonProperty(name, value, hres))
+      {
+        RINOK(hres)
+        continue;
+      }
     }
+    RINOK(ParseMethodFromPROPVARIANT(names[i], value));
   }
+
   return S_OK;
 }
 
+#endif
+
 }

CPP/7zip/Archive/Common/HandlerOut.h

@@ -3,20 +3,57 @@
 #ifndef __HANDLER_OUT_H
 #define __HANDLER_OUT_H
 
+#include "../../../Windows/System.h"
+
 #include "../../Common/MethodProps.h"
 
 namespace NArchive {
 
-class CMultiMethodProps
+bool ParseSizeString(const wchar_t *name, const PROPVARIANT &prop, UInt64 percentsBase, UInt64 &res);
+
+class CCommonMethodProps
 {
-  UInt32 _level;
-  int _analysisLevel;
+protected:
+  void InitCommon()
+  {
+    #ifndef _7ZIP_ST
+    _numProcessors = _numThreads = NWindows::NSystem::GetNumberOfProcessors();
+    #endif
+
+    UInt64 memAvail = (UInt64)(sizeof(size_t)) << 28;
+    _memAvail = memAvail;
+    _memUsage = memAvail;
+    if (NWindows::NSystem::GetRamSize(memAvail))
+    {
+      _memAvail = memAvail;
+      _memUsage = memAvail / 32 * 17;
+    }
+  }
+
 public:
   #ifndef _7ZIP_ST
   UInt32 _numThreads;
   UInt32 _numProcessors;
   #endif
 
+  UInt64 _memUsage;
+  UInt64 _memAvail;
+
+  bool SetCommonProperty(const UString &name, const PROPVARIANT &value, HRESULT &hres);
+
+  CCommonMethodProps() { InitCommon(); }
+};
+
+
+#ifndef EXTRACT_ONLY
+
+class CMultiMethodProps: public CCommonMethodProps
+{
+  UInt32 _level;
+  int _analysisLevel;
+
+  void InitMulti();
+public:
   UInt32 _crcSize;
   CObjectVector<COneMethodInfo> _methods;
   COneMethodInfo _filterMethod;
@@ -43,27 +80,31 @@ public:
   int GetAnalysisLevel() const { return _analysisLevel; }
 
   void Init();
+  CMultiMethodProps() { InitMulti(); }
 
-  CMultiMethodProps() { Init(); }
   HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
 };
 
-class CSingleMethodProps: public COneMethodInfo
+
+class CSingleMethodProps: public COneMethodInfo, public CCommonMethodProps
 {
   UInt32 _level;
-  
-public:
-  #ifndef _7ZIP_ST
-  UInt32 _numThreads;
-  UInt32 _numProcessors;
-  #endif
 
+  void InitSingle()
+  {
+    _level = (UInt32)(Int32)-1;
+  }
+
+public:
   void Init();
-  CSingleMethodProps() { Init(); }
+  CSingleMethodProps() { InitSingle(); }
+  
   int GetLevel() const { return _level == (UInt32)(Int32)-1 ? 5 : (int)_level; }
   HRESULT SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
 };
 
+#endif
+
 }
 
 #endif

CPP/7zip/Archive/IArchive.h

@@ -488,6 +488,16 @@ ARCHIVE_INTERFACE(IOutArchive, 0xA0)
 };
 
 
+/*
+ISetProperties::SetProperties()
+  PROPVARIANT values[i].vt:
+    VT_EMPTY
+    VT_BOOL
+    VT_UI4   - if 32-bit number
+    VT_UI8   - if 64-bit number
+    VT_BSTR
+*/
+
 ARCHIVE_INTERFACE(ISetProperties, 0x03)
 {
   STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps) PURE;

CPP/7zip/Archive/Rar/Rar5Handler.cpp

@@ -1086,7 +1086,7 @@ HRESULT CUnpacker::Create(DECL_EXTERNAL_CODECS_LOC_VARS const CItem &item, bool
     if (!lzCoder)
     {
       const UInt32 methodID = 0x40305;
-      RINOK(CreateCoder(EXTERNAL_CODECS_LOC_VARS methodID, false, lzCoder));
+      RINOK(CreateCoder_Id(EXTERNAL_CODECS_LOC_VARS methodID, false, lzCoder));
       if (!lzCoder)
         return E_NOTIMPL;
     }

CPP/7zip/Archive/Rar/RarHandler.cpp

@@ -1691,7 +1691,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
               methodID += 2;
             else
               methodID += 3;
-            RINOK(CreateCoder(EXTERNAL_CODECS_VARS methodID, false, mi.Coder));
+            RINOK(CreateCoder_Id(EXTERNAL_CODECS_VARS methodID, false, mi.Coder));
           }
          
           if (mi.Coder == 0)

CPP/7zip/Archive/SquashfsHandler.cpp

@@ -2,7 +2,6 @@
 
 #include "StdAfx.h"
 
-#include "../../../C/7zCrc.h"
 #include "../../../C/Alloc.h"
 #include "../../../C/CpuArch.h"
 #include "../../../C/Xz.h"
@@ -1209,8 +1208,10 @@ HRESULT CHandler::Decompress(ISequentialOutStream *outStream, Byte *outBuf, bool
     else
     {
       ECoderStatus status;
-      XzUnpacker_Init(&_xz);
-      SRes res = XzUnpacker_Code(&_xz, dest, &destLen, _inputBuffer, &srcLen, CODER_FINISH_END, &status);
+      SRes res = XzUnpacker_CodeFull(&_xz,
+          dest, &destLen,
+          _inputBuffer, &srcLen,
+          CODER_FINISH_END, &status);
       if (res != 0)
         return SResToHRESULT(res);
       if (status != CODER_STATUS_NEEDS_MORE_INPUT || !XzUnpacker_IsStreamWasFinished(&_xz))

CPP/7zip/Archive/XzHandler.cpp

@@ -24,9 +24,7 @@
 
 #include "IArchive.h"
 
-#ifndef EXTRACT_ONLY
 #include "Common/HandlerOut.h"
-#endif
 
 using namespace NWindows;
 
@@ -49,14 +47,22 @@ class CHandler:
   public IInArchive,
   public IArchiveOpenSeq,
   public IInArchiveGetStream,
+  public ISetProperties,
+
   #ifndef EXTRACT_ONLY
   public IOutArchive,
-  public ISetProperties,
-  public CMultiMethodProps,
   #endif
-  public CMyUnknownImp
+
+  public CMyUnknownImp,
+
+  #ifndef EXTRACT_ONLY
+    public CMultiMethodProps
+  #else
+    public CCommonMethodProps
+  #endif
 {
-  NCompress::NXz::CStatInfo _stat;
+  CXzStatInfo _stat;
+  SRes MainDecodeSRes;
   
   bool _isArc;
   bool _needSeekToStart;
@@ -71,34 +77,48 @@ class CHandler:
 
   UInt64 _numSolidBytes;
 
-  HRESULT SetSolidFromString(const UString &s);
-  HRESULT SetSolidFromPROPVARIANT(const PROPVARIANT &value);
-  HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
-
-  void InitSolid()
+  void InitXz()
   {
+    _filterId = 0;
     _numSolidBytes = XZ_PROPS__BLOCK_SIZE__AUTO;
   }
 
+  #endif
+
   void Init()
   {
-    InitSolid();
-    _filterId = 0;
-    CMultiMethodProps::Init();
+    #ifndef EXTRACT_ONLY
+      InitXz();
+      CMultiMethodProps::Init();
+    #else
+      CCommonMethodProps::InitCommon();
+    #endif
   }
   
-  #endif
+  HRESULT SetProperty(const wchar_t *name, const PROPVARIANT &value);
 
   HRESULT Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCallback *callback);
 
-  HRESULT Decode2(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
-      NCompress::NXz::CDecoder &decoder, ICompressProgressInfo *progress)
+  HRESULT Decode(NCompress::NXz::CDecoder &decoder,
+      ISequentialInStream *seqInStream,
+      ISequentialOutStream *outStream,
+      ICompressProgressInfo *progress)
   {
+    #ifndef _7ZIP_ST
+    decoder._numThreads = _numThreads;
+    #endif
+    decoder._memUsage = _memUsage;
+
+    MainDecodeSRes = SZ_OK;
+
     RINOK(decoder.Decode(seqInStream, outStream,
         NULL, // *outSizeLimit
         true, // finishStream
         progress));
-    _stat = decoder;
+    
+    _stat = decoder.Stat;
+    MainDecodeSRes = decoder.MainDecodeSRes;
+
     _phySize_Defined = true;
     return S_OK;
   }
@@ -107,9 +127,9 @@ public:
   MY_QUERYINTERFACE_BEGIN2(IInArchive)
   MY_QUERYINTERFACE_ENTRY(IArchiveOpenSeq)
   MY_QUERYINTERFACE_ENTRY(IInArchiveGetStream)
+  MY_QUERYINTERFACE_ENTRY(ISetProperties)
   #ifndef EXTRACT_ONLY
   MY_QUERYINTERFACE_ENTRY(IOutArchive)
-  MY_QUERYINTERFACE_ENTRY(ISetProperties)
   #endif
   MY_QUERYINTERFACE_END
   MY_ADDREF_RELEASE
@@ -117,10 +137,10 @@ public:
   INTERFACE_IInArchive(;)
   STDMETHOD(OpenSeq)(ISequentialInStream *stream);
   STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+  STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
 
   #ifndef EXTRACT_ONLY
   INTERFACE_IOutArchive(;)
-  STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
   #endif
 
   size_t _blocksArraySize;
@@ -146,7 +166,7 @@ CHandler::CHandler():
     _blocksArraySize(0)
 {
   #ifndef EXTRACT_ONLY
-  Init();
+  InitXz();
   #endif
 }
 
@@ -307,7 +327,7 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
   NCOM::CPropVariant prop;
   switch (propID)
   {
-    case kpidPhySize: if (_phySize_Defined) prop = _stat.PhySize; break;
+    case kpidPhySize: if (_phySize_Defined) prop = _stat.InSize; break;
     case kpidNumStreams: if (_stat.NumStreams_Defined) prop = _stat.NumStreams; break;
     case kpidNumBlocks: if (_stat.NumBlocks_Defined) prop = _stat.NumBlocks; break;
     case kpidUnpackSize: if (_stat.UnpackSize_Defined) prop = _stat.OutSize; break;
@@ -330,19 +350,22 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
     case kpidErrorFlags:
     {
       UInt32 v = 0;
+      SRes sres = MainDecodeSRes; // _stat.DecodeRes2; //
       if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
-      if (_stat.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+      if (/*_stat.UnexpectedEnd */ sres == SZ_ERROR_INPUT_EOF) v |= kpv_ErrorFlags_UnexpectedEnd;
       if (_stat.DataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
-      if (_stat.HeadersError) v |= kpv_ErrorFlags_HeadersError;
-      if (_stat.Unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
-      if (_stat.DataError) v |= kpv_ErrorFlags_DataError;
-      if (_stat.CrcError) v |= kpv_ErrorFlags_CrcError;
-      prop = v;
+      if (/* _stat.HeadersError */ sres == SZ_ERROR_ARCHIVE) v |= kpv_ErrorFlags_HeadersError;
+      if (/* _stat.Unsupported */ sres == SZ_ERROR_UNSUPPORTED) v |= kpv_ErrorFlags_UnsupportedMethod;
+      if (/* _stat.DataError */ sres == SZ_ERROR_DATA) v |= kpv_ErrorFlags_DataError;
+      if (/* _stat.CrcError */ sres == SZ_ERROR_CRC) v |= kpv_ErrorFlags_CrcError;
+      if (v != 0)
+        prop = v;
       break;
     }
 
     case kpidMainSubfile:
     {
+      // debug only, comment it:
       // if (_blocks) prop = (UInt32)0;
       break;
     }
@@ -365,7 +388,7 @@ STDMETHODIMP CHandler::GetProperty(UInt32, PROPID propID, PROPVARIANT *value)
   switch (propID)
   {
     case kpidSize: if (_stat.UnpackSize_Defined) prop = _stat.OutSize; break;
-    case kpidPackSize: if (_phySize_Defined) prop = _stat.PhySize; break;
+    case kpidPackSize: if (_phySize_Defined) prop = _stat.InSize; break;
     case kpidMethod: if (!_methodsString.IsEmpty()) prop = _methodsString; break;
   }
   prop.Detach(value);
@@ -483,10 +506,10 @@ HRESULT CHandler::Open2(IInStream *inStream, /* UInt32 flags, */ IArchiveOpenCal
     }
   }
 
-  RINOK(inStream->Seek(0, STREAM_SEEK_END, &_stat.PhySize));
+  RINOK(inStream->Seek(0, STREAM_SEEK_END, &_stat.InSize));
   if (callback)
   {
-    RINOK(callback->SetTotal(NULL, &_stat.PhySize));
+    RINOK(callback->SetTotal(NULL, &_stat.InSize));
   }
 
   CSeekInStreamWrap inStreamImp;
@@ -621,7 +644,7 @@ STDMETHODIMP CHandler::OpenSeq(ISequentialInStream *stream)
 
 STDMETHODIMP CHandler::Close()
 {
-  _stat.Clear();
+  XzStatInfo_Clear(&_stat);
 
   _isArc = false;
   _needSeekToStart = false;
@@ -637,6 +660,8 @@ STDMETHODIMP CHandler::Close()
   _blocksArraySize = 0;
   _maxBlocksSize = 0;
 
+  MainDecodeSRes = SZ_OK;
+
   return S_OK;
 }
 
@@ -743,6 +768,8 @@ static HRESULT DecodeBlock(CXzUnpackerCPP2 &xzu,
   xzu.p.streamFlags = (UInt16)streamFlags;
   XzUnpacker_PrepareToRandomBlockDecoding(&xzu.p);
 
+  XzUnpacker_SetOutBuf(&xzu.p, dest, unpackSize);
+
   const UInt64 packSizeAligned = packSize + ((0 - (unsigned)packSize) & 3);
   UInt64 packRem = packSizeAligned;
 
@@ -771,8 +798,11 @@ static HRESULT DecodeBlock(CXzUnpackerCPP2 &xzu,
     ECoderStatus status;
 
     SRes res = XzUnpacker_Code(&xzu.p,
-        dest + outPos, &outLen,
+        // dest + outPos,
+        NULL,
+        &outLen,
         xzu.InBuf + inPos, &inLen,
+        (inLen == 0), // srcFinished
         CODER_FINISH_END, &status);
 
     // return E_OUTOFMEMORY;
@@ -890,15 +920,16 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
     return E_INVALIDARG;
 
   if (!_stat.UnpackSize_Defined
+      || _maxBlocksSize == 0 // 18.02
       || _maxBlocksSize > kMaxBlockSize_for_GetStream
       || _maxBlocksSize != (size_t)_maxBlocksSize)
     return S_FALSE;
 
-  UInt64 physSize = (UInt64)(sizeof(size_t)) << 29;
-  bool ramSize_Defined = NSystem::GetRamSize(physSize);
-  if (ramSize_Defined)
+  UInt64 memSize;
+  if (!NSystem::GetRamSize(memSize))
+    memSize = (UInt64)(sizeof(size_t)) << 28;
   {
-    if (_maxBlocksSize > physSize / 4)
+    if (_maxBlocksSize > memSize / 4)
       return S_FALSE;
   }
 
@@ -917,6 +948,31 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
 }
 
 
+static Int32 Get_Extract_OperationResult(const NCompress::NXz::CDecoder &decoder)
+{
+  Int32 opRes;
+  SRes sres = decoder.MainDecodeSRes; // decoder.Stat.DecodeRes2;
+  if (sres == SZ_ERROR_NO_ARCHIVE) // (!IsArc)
+    opRes = NExtract::NOperationResult::kIsNotArc;
+  else if (sres == SZ_ERROR_INPUT_EOF) // (UnexpectedEnd)
+    opRes = NExtract::NOperationResult::kUnexpectedEnd;
+  else if (decoder.Stat.DataAfterEnd)
+    opRes = NExtract::NOperationResult::kDataAfterEnd;
+  else if (sres == SZ_ERROR_CRC) // (CrcError)
+    opRes = NExtract::NOperationResult::kCRCError;
+  else if (sres == SZ_ERROR_UNSUPPORTED) // (Unsupported)
+    opRes = NExtract::NOperationResult::kUnsupportedMethod;
+  else if (sres == SZ_ERROR_ARCHIVE) //  (HeadersError)
+    opRes = NExtract::NOperationResult::kDataError;
+  else if (sres == SZ_ERROR_DATA)  // (DataError)
+    opRes = NExtract::NOperationResult::kDataError;
+  else if (sres != SZ_OK)
+    opRes = NExtract::NOperationResult::kDataError;
+  else
+    opRes = NExtract::NOperationResult::kOK;
+  return opRes;
+}
+
 
 
 
@@ -930,7 +986,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     return E_INVALIDARG;
 
   if (_phySize_Defined)
-    extractCallback->SetTotal(_stat.PhySize);
+    extractCallback->SetTotal(_stat.InSize);
 
   UInt64 currentTotalPacked = 0;
   RINOK(extractCallback->SetCompleted(&currentTotalPacked));
@@ -959,9 +1015,18 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   else
     _needSeekToStart = true;
 
+
   NCompress::NXz::CDecoder decoder;
-  RINOK(Decode2(_seqStream, realOutStream, decoder, lpsRef));
-  Int32 opRes = decoder.Get_Extract_OperationResult();
+
+  HRESULT hres = Decode(decoder, _seqStream, realOutStream, lpsRef);
+
+  if (!decoder.MainDecodeSRes_wasUsed)
+    return hres == S_OK ? E_FAIL : hres;
+
+  Int32 opRes = Get_Extract_OperationResult(decoder);
+  if (opRes == NExtract::NOperationResult::kOK
+      && hres != S_OK)
+    opRes = NExtract::NOperationResult::kDataError;
 
   realOutStream.Release();
   return extractCallback->SetOperationResult(opRes);
@@ -1112,7 +1177,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
   if (_stream)
   {
     if (_phySize_Defined)
-      RINOK(updateCallback->SetTotal(_stat.PhySize));
+      RINOK(updateCallback->SetTotal(_stat.InSize));
     RINOK(_stream->Seek(0, STREAM_SEEK_SET, NULL));
   }
 
@@ -1125,55 +1190,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
   COM_TRY_END
 }
 
-
-HRESULT CHandler::SetSolidFromString(const UString &s)
-{
-  UString s2 = s;
-  s2.MakeLower_Ascii();
-
-  {
-    const wchar_t *start = ((const wchar_t *)s2);
-    const wchar_t *end;
-    UInt64 v = ConvertStringToUInt64(start, &end);
-    if (start == end)
-      return E_INVALIDARG;
-    if ((unsigned)(end - start) + 1 != s2.Len())
-      return E_INVALIDARG;
-    wchar_t c = *end;
-    {
-      unsigned numBits;
-      switch (c)
-      {
-        case 'b': numBits =  0; break;
-        case 'k': numBits = 10; break;
-        case 'm': numBits = 20; break;
-        case 'g': numBits = 30; break;
-        case 't': numBits = 40; break;
-        default: return E_INVALIDARG;
-      }
-      _numSolidBytes = (v << numBits);
-    }
-  }
-  return S_OK;
-}
-
-
-HRESULT CHandler::SetSolidFromPROPVARIANT(const PROPVARIANT &value)
-{
-  bool isSolid;
-  switch (value.vt)
-  {
-    case VT_EMPTY: isSolid = true; break;
-    case VT_BOOL: isSolid = (value.boolVal != VARIANT_FALSE); break;
-    case VT_BSTR:
-      if (StringToBool(value.bstrVal, isSolid))
-        break;
-      return SetSolidFromString(value.bstrVal);
-    default: return E_INVALIDARG;
-  }
-  _numSolidBytes = (isSolid ? XZ_PROPS__BLOCK_SIZE__SOLID : XZ_PROPS__BLOCK_SIZE__AUTO);
-  return S_OK;
-}
+#endif
 
 
 HRESULT CHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
@@ -1183,20 +1200,53 @@ HRESULT CHandler::SetProperty(const wchar_t *nameSpec, const PROPVARIANT &value)
   if (name.IsEmpty())
     return E_INVALIDARG;
   
+  #ifndef EXTRACT_ONLY
+
   if (name[0] == L's')
   {
-    name.Delete(0);
-    if (name.IsEmpty())
-      return SetSolidFromPROPVARIANT(value);
-    if (value.vt != VT_EMPTY)
-      return E_INVALIDARG;
-    return SetSolidFromString(name);
+    const wchar_t *s = name.Ptr(1);
+    if (*s == 0)
+    {
+      bool useStr = false;
+      bool isSolid;
+      switch (value.vt)
+      {
+        case VT_EMPTY: isSolid = true; break;
+        case VT_BOOL: isSolid = (value.boolVal != VARIANT_FALSE); break;
+        case VT_BSTR:
+          if (!StringToBool(value.bstrVal, isSolid))
+            useStr = true;
+          break;
+        default: return E_INVALIDARG;
+      }
+      if (!useStr)
+      {
+        _numSolidBytes = (isSolid ? XZ_PROPS__BLOCK_SIZE__SOLID : XZ_PROPS__BLOCK_SIZE__AUTO);
+        return S_OK;
+      }
+    }
+    return ParseSizeString(s, value,
+        0, // percentsBase
+        _numSolidBytes) ? S_OK: E_INVALIDARG;
   }
-  
+
   return CMultiMethodProps::SetProperty(name, value);
+
+  #else
+
+  {
+    HRESULT hres;
+    if (SetCommonProperty(name, value, hres))
+      return hres;
+  }
+
+  return E_INVALIDARG;
+  
+  #endif
 }
 
 
+
 STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
 {
   COM_TRY_BEGIN
@@ -1208,6 +1258,8 @@ STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
     RINOK(SetProperty(names[i], values[i]));
   }
 
+  #ifndef EXTRACT_ONLY
+
   if (!_filterMethod.MethodName.IsEmpty())
   {
     unsigned k;
@@ -1238,12 +1290,13 @@ STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVAR
       return E_INVALIDARG;
   }
   
+  #endif
+
   return S_OK;
 
   COM_TRY_END
 }
 
-#endif
 
 REGISTER_ARC_IO(
   "xz", "xz txz", "* .tar", 0xC,

CPP/7zip/Archive/Zip/ZipAddCommon.cpp

@@ -384,7 +384,7 @@ HRESULT CAddCommon::Compress(
               methodId = kMethodId_ZipBase + method;
               break;
           }
-          RINOK(CreateCoder(
+          RINOK(CreateCoder_Id(
               EXTERNAL_CODECS_LOC_VARS
               methodId, true, _compressEncoder));
           if (!_compressEncoder)

CPP/7zip/Archive/Zip/ZipHandler.cpp

@@ -112,7 +112,8 @@ static const CUInt32PCharPair g_HeaderCharacts[] =
   { 3, "Descriptor" },
   // { 5, "Patched" },
   { 6, kMethod_StrongCrypto },
-  { 11, "UTF8" }
+  { 11, "UTF8" },
+  { 14, "Alt" }
 };
 
 struct CIdToNamePair
@@ -169,6 +170,7 @@ static const Byte kProps[] =
   kpidUnpackVer,
   kpidVolumeIndex,
   kpidOffset
+  // kpidIsAltStream
 };
 
 static const Byte kArcProps[] =
@@ -307,6 +309,8 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
           prop = true;
       break;
     }
+
+    // case kpidIsAltStream: prop = true; break;
   }
   prop.Detach(value);
   COM_TRY_END
@@ -333,6 +337,21 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
       UString res;
       item.GetUnicodeString(res, item.Name, false, _forceCodePage, _specifiedCodePage);
       NItemName::ReplaceToOsSlashes_Remove_TailSlash(res);
+      /*
+      if (item.ParentOfAltStream >= 0)
+      {
+        const CItemEx &prevItem = m_Items[item.ParentOfAltStream];
+        UString prevName;
+        prevItem.GetUnicodeString(prevName, prevItem.Name, false, _forceCodePage, _specifiedCodePage);
+        NItemName::ReplaceToOsSlashes_Remove_TailSlash(prevName);
+        if (res.IsPrefixedBy(prevName))
+          if (IsString1PrefixedByString2(res.Ptr(prevName.Len()), k_SpecName_NTFS_STREAM))
+          {
+            res.Delete(prevName.Len(), (unsigned)strlen(k_SpecName_NTFS_STREAM));
+            res.Insert(prevName.Len(), L":");
+          }
+      }
+      */
       prop = res;
       break;
     }
@@ -596,6 +615,19 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
     case kpidOffset:
       prop = item.LocalHeaderPos;
       break;
+
+    /*
+    case kpidIsAltStream:
+      prop = (bool)(item.ParentOfAltStream >= 0); // item.IsAltStream();
+      break;
+
+    case kpidName:
+      if (item.ParentOfAltStream >= 0)
+      {
+        // extract name of stream here
+      }
+      break;
+    */
   }
   
   prop.Detach(value);
@@ -604,6 +636,85 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
 }
 
 
+
+/*
+STDMETHODIMP CHandler::GetNumRawProps(UInt32 *numProps)
+{
+  *numProps = 0;
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID)
+{
+  UNUSED_VAR(index);
+  *propID = 0;
+  *name = 0;
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType)
+{
+  *parentType = NParentType::kDir;
+  *parent = (UInt32)(Int32)-1;
+  if (index >= m_Items.Size())
+    return S_OK;
+  const CItemEx &item = m_Items[index];
+
+  if (item.ParentOfAltStream >= 0)
+  {
+    *parentType = NParentType::kAltStream;
+    *parent = item.ParentOfAltStream;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)
+{
+  UNUSED_VAR(index);
+  UNUSED_VAR(propID);
+  *data = NULL;
+  *dataSize = 0;
+  *propType = 0;
+  return S_OK;
+}
+
+
+void CHandler::MarkAltStreams(CObjectVector<CItemEx> &items)
+{
+  int prevIndex = -1;
+  UString prevName;
+  UString name;
+
+  for (unsigned i = 0; i < items.Size(); i++)
+  {
+    CItemEx &item = m_Items[i];
+    if (item.IsAltStream())
+    {
+      if (prevIndex == -1)
+        continue;
+      if (prevName.IsEmpty())
+      {
+        const CItemEx &prevItem = m_Items[prevIndex];
+        prevItem.GetUnicodeString(prevName, prevItem.Name, false, _forceCodePage, _specifiedCodePage);
+        NItemName::ReplaceToOsSlashes_Remove_TailSlash(prevName);
+      }
+      name.Empty();
+      item.GetUnicodeString(name, item.Name, false, _forceCodePage, _specifiedCodePage);
+      NItemName::ReplaceToOsSlashes_Remove_TailSlash(name);
+      
+      if (name.IsPrefixedBy(prevName))
+        if (IsString1PrefixedByString2(name.Ptr(prevName.Len()), k_SpecName_NTFS_STREAM))
+          item.ParentOfAltStream = prevIndex;
+    }
+    else
+    {
+      prevIndex = i;
+      prevName.Empty();
+    }
+  }
+}
+*/
+
 STDMETHODIMP CHandler::Open(IInStream *inStream,
     const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback)
 {
@@ -617,6 +728,7 @@ STDMETHODIMP CHandler::Open(IInStream *inStream,
       m_Items.Clear();
       m_Archive.ClearRefs(); // we don't want to clear error flags
     }
+    // MarkAltStreams(m_Items);
     return res;
   }
   catch(...) { Close(); throw; }
@@ -738,7 +850,7 @@ public:
     IArchiveExtractCallback *extractCallback,
     ICompressProgressInfo *compressProgress,
     #ifndef _7ZIP_ST
-    UInt32 numThreads,
+    UInt32 numThreads, UInt64 memUsage,
     #endif
     Int32 &res);
 };
@@ -767,7 +879,7 @@ HRESULT CZipDecoder::Decode(
     IArchiveExtractCallback *extractCallback,
     ICompressProgressInfo *compressProgress,
     #ifndef _7ZIP_ST
-    UInt32 numThreads,
+    UInt32 numThreads, UInt64 memUsage,
     #endif
     Int32 &res)
 {
@@ -962,7 +1074,7 @@ HRESULT CZipDecoder::Decode(
         szMethodID = kMethodId_ZipBase + (Byte)id;
       }
 
-      RINOK(CreateCoder(EXTERNAL_CODECS_LOC_VARS szMethodID, false, mi.Coder));
+      RINOK(CreateCoder_Id(EXTERNAL_CODECS_LOC_VARS szMethodID, false, mi.Coder));
 
       if (!mi.Coder)
       {
@@ -974,16 +1086,7 @@ HRESULT CZipDecoder::Decode(
   }
 
   ICompressCoder *coder = methodItems[m].Coder;
-  
-  {
-    CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties;
-    coder->QueryInterface(IID_ICompressSetDecoderProperties2, (void **)&setDecoderProperties);
-    if (setDecoderProperties)
-    {
-      Byte properties = (Byte)item.Flags;
-      RINOK(setDecoderProperties->SetDecoderProperties2(&properties, 1));
-    }
-  }
+
   
   #ifndef _7ZIP_ST
   {
@@ -994,7 +1097,27 @@ HRESULT CZipDecoder::Decode(
       RINOK(setCoderMt->SetNumberOfThreads(numThreads));
     }
   }
+  // if (memUsage != 0)
+  {
+    CMyComPtr<ICompressSetMemLimit> setMemLimit;
+    coder->QueryInterface(IID_ICompressSetMemLimit, (void **)&setMemLimit);
+    if (setMemLimit)
+    {
+      RINOK(setMemLimit->SetMemLimit(memUsage));
+    }
+  }
   #endif
+
+  {
+    CMyComPtr<ICompressSetDecoderProperties2> setDecoderProperties;
+    coder->QueryInterface(IID_ICompressSetDecoderProperties2, (void **)&setDecoderProperties);
+    if (setDecoderProperties)
+    {
+      Byte properties = (Byte)item.Flags;
+      RINOK(setDecoderProperties->SetDecoderProperties2(&properties, 1));
+    }
+  }
+  
   
   CMyComPtr<ISequentialInStream> inStreamNew;
 
@@ -1319,7 +1442,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
         m_Archive, item, realOutStream, extractCallback,
         progress,
         #ifndef _7ZIP_ST
-        _props._numThreads,
+        _props._numThreads, _props._memUsage,
         #endif
         res);
     

CPP/7zip/Archive/Zip/ZipHandler.h

@@ -25,6 +25,7 @@ extern const char * const kMethodNames2[kNumMethodNames2];
 
 class CHandler:
   public IInArchive,
+  // public IArchiveGetRawProps,
   public IOutArchive,
   public ISetProperties,
   PUBLIC_ISetCompressCodecsInfo
@@ -32,6 +33,7 @@ class CHandler:
 {
 public:
   MY_QUERYINTERFACE_BEGIN2(IInArchive)
+  // MY_QUERYINTERFACE_ENTRY(IArchiveGetRawProps)
   MY_QUERYINTERFACE_ENTRY(IOutArchive)
   MY_QUERYINTERFACE_ENTRY(ISetProperties)
   QUERY_ENTRY_ISetCompressCodecsInfo
@@ -39,6 +41,7 @@ public:
   MY_ADDREF_RELEASE
 
   INTERFACE_IInArchive(;)
+  // INTERFACE_IArchiveGetRawProps(;)
   INTERFACE_IOutArchive(;)
 
   STDMETHOD(SetProperties)(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps);
@@ -75,6 +78,10 @@ private:
     _forceCodePage = false;
     _specifiedCodePage = CP_OEMCP;
   }
+
+  // void MarkAltStreams(CObjectVector<CItemEx> &items);
+
+  HRESULT GetOutProperty(IArchiveUpdateCallback *callback, UInt32 callbackIndex, Int32 arcIndex, PROPID propID, PROPVARIANT *value);
 };
 
 }}

CPP/7zip/Archive/Zip/ZipHandlerOut.cpp

@@ -376,7 +376,8 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
         {
           CMethodId methodId;
           UInt32 numStreams;
-          if (!FindMethod(EXTERNAL_CODECS_VARS methodName, methodId, numStreams))
+          if (FindMethod_Index(EXTERNAL_CODECS_VARS methodName, true,
+              methodId, numStreams) < 0)
             return E_NOTIMPL;
           if (numStreams != 1)
             return E_NOTIMPL;