react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/MethodProps.h

@@ -1,7 +1,7 @@
 // MethodProps.h
 
-#ifndef ZIP7_INC_7Z_METHOD_PROPS_H
-#define ZIP7_INC_7Z_METHOD_PROPS_H
+#ifndef __7Z_METHOD_PROPS_H
+#define __7Z_METHOD_PROPS_H
 
 #include "../../Common/MyString.h"
 #include "../../Common/Defs.h"
@@ -12,38 +12,12 @@
 
 #include "../ICoder.h"
 
-// UInt64 GetMemoryUsage_LZMA(UInt32 dict, bool isBt, UInt32 numThreads);
-
-inline UInt64 Calc_From_Val_Percents_Less100(UInt64 val, UInt64 percents)
-{
-  if (percents == 0)
-    return 0;
-  if (val <= (UInt64)(Int64)-1 / percents)
-    return val * percents / 100;
-  return val / 100 * percents;
-}
-
-UInt64 Calc_From_Val_Percents(UInt64 val, UInt64 percents);
-
 bool StringToBool(const wchar_t *s, bool &res);
 HRESULT PROPVARIANT_to_bool(const PROPVARIANT &prop, bool &dest);
 unsigned ParseStringToUInt32(const UString &srcString, UInt32 &number);
-
-/*
-if (name.IsEmpty() && prop.vt == VT_EMPTY), it doesn't change (resValue) and returns S_OK.
-  So you must set (resValue) for default value before calling */
 HRESULT ParsePropToUInt32(const UString &name, const PROPVARIANT &prop, UInt32 &resValue);
 
-/* input: (numThreads = the_number_of_processors) */
-HRESULT ParseMtProp2(const UString &name, const PROPVARIANT &prop, UInt32 &numThreads, bool &force);
-
-inline HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 numCPUs, UInt32 &numThreads)
-{
-  bool forced = false;
-  numThreads = numCPUs;
-  return ParseMtProp2(name, prop, numThreads, forced);
-}
-
+HRESULT ParseMtProp(const UString &name, const PROPVARIANT &prop, UInt32 defaultNumThreads, UInt32 &numThreads);
 
 struct CProp
 {
@@ -79,49 +53,33 @@ struct CProps
     prop.Value = s;
   }
 
-  HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce = NULL) const;
-  HRESULT SetCoderProps_DSReduce_Aff(ICompressSetCoderProperties *scp,
-      const UInt64 *dataSizeReduce,
-      const UInt64 *affinity,
-      const UInt32 *affinityGroup,
-      const UInt64 *affinityInGroup) const;
+  HRESULT SetCoderProps(ICompressSetCoderProperties *scp, const UInt64 *dataSizeReduce) const;
 };
 
 class CMethodProps: public CProps
 {
   HRESULT SetParam(const UString &name, const UString &value);
 public:
-  unsigned GetLevel() const;
+  int GetLevel() const;
   int Get_NumThreads() const
   {
-    const int i = FindProp(NCoderPropID::kNumThreads);
+    int i = FindProp(NCoderPropID::kNumThreads);
     if (i >= 0)
-    {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
-      if (val.vt == VT_UI4)
-        return (int)val.ulVal;
-    }
+      if (Props[i].Value.vt == VT_UI4)
+        return (int)Props[i].Value.ulVal;
     return -1;
   }
 
-  bool Get_DicSize(UInt64 &res) const
+  bool Get_DicSize(UInt32 &res) const
   {
     res = 0;
-    const int i = FindProp(NCoderPropID::kDictionarySize);
+    int i = FindProp(NCoderPropID::kDictionarySize);
     if (i >= 0)
-    {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
-      if (val.vt == VT_UI4)
-      {
-        res = val.ulVal;
-        return true;
-      }
-      if (val.vt == VT_UI8)
+      if (Props[i].Value.vt == VT_UI4)
       {
-        res = val.uhVal.QuadPart;
+        res = Props[i].Value.ulVal;
         return true;
       }
-    }
     return false;
   }
 
@@ -129,48 +87,29 @@ public:
 
   UInt32 Get_Lzma_Algo() const
   {
-    const int i = FindProp(NCoderPropID::kAlgorithm);
+    int i = FindProp(NCoderPropID::kAlgorithm);
     if (i >= 0)
-    {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
-      if (val.vt == VT_UI4)
-        return val.ulVal;
-    }
+      if (Props[i].Value.vt == VT_UI4)
+        return Props[i].Value.ulVal;
     return GetLevel() >= 5 ? 1 : 0;
   }
 
-  UInt64 Get_Lzma_DicSize() const
-  {
-    UInt64 v;
-    if (Get_DicSize(v))
-      return v;
-    const unsigned level = GetLevel();
-    const UInt32 dictSize = level <= 4 ?
-        (UInt32)1 << (level * 2 + 16) :
-        level <= sizeof(size_t) / 2 + 4 ?
-          (UInt32)1 << (level + 20) :
-          (UInt32)1 << (sizeof(size_t) / 2 + 24);
-    return dictSize;
-  }
-
-  bool Get_Lzma_MatchFinder_IsBt() const
+  UInt32 Get_Lzma_DicSize() const
   {
-    const int i = FindProp(NCoderPropID::kMatchFinder);
+    int i = FindProp(NCoderPropID::kDictionarySize);
     if (i >= 0)
-    {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
-      if (val.vt == VT_BSTR)
-        return ((val.bstrVal[0] | 0x20) != 'h'); // check for "hc"
-    }
-    return GetLevel() >= 5;
+      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 Get_Lzma_Eos() const
   {
-    const int i = FindProp(NCoderPropID::kEndMarker);
+    int i = FindProp(NCoderPropID::kEndMarker);
     if (i >= 0)
     {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+      const NWindows::NCOM::CPropVariant &val = Props[i].Value;
       if (val.vt == VT_BOOL)
         return VARIANT_BOOLToBool(val.boolVal);
     }
@@ -195,9 +134,6 @@ public:
     return 2;
   }
 
-  UInt64 Get_Lzma_MemUsage(bool addSlidingWindowSize) const;
-
-  /* returns -1, if numThreads is unknown */
   int Get_Xz_NumThreads(UInt32 &lzmaThreads) const
   {
     lzmaThreads = 1;
@@ -211,10 +147,10 @@ public:
 
   UInt64 GetProp_BlockSize(PROPID id) const
   {
-    const int i = FindProp(id);
+    int i = FindProp(id);
     if (i >= 0)
     {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
+      const NWindows::NCOM::CPropVariant &val = Props[i].Value;
       if (val.vt == VT_UI4) { return val.ulVal; }
       if (val.vt == VT_UI8) { return val.uhVal.QuadPart; }
     }
@@ -235,8 +171,7 @@ public:
     }
     const UInt32 kMinSize = (UInt32)1 << 20;
     const UInt32 kMaxSize = (UInt32)1 << 28;
-    const UInt64 dictSize = Get_Lzma_DicSize();
-    /* lzma2 code uses fake 4 GiB to calculate ChunkSize. So we do same */
+    UInt32 dictSize = Get_Lzma_DicSize();
     UInt64 blockSize = (UInt64)dictSize << 2;
     if (blockSize < kMinSize) blockSize = kMinSize;
     if (blockSize > kMaxSize) blockSize = kMaxSize;
@@ -256,46 +191,37 @@ public:
       fixedNumber = true;
       if (numThreads < 1) return 1;
       const unsigned kNumBZip2ThreadsMax = 64;
-      if ((unsigned)numThreads > kNumBZip2ThreadsMax) return kNumBZip2ThreadsMax;
-      return (unsigned)numThreads;
+      if (numThreads > kNumBZip2ThreadsMax) return kNumBZip2ThreadsMax;
+      return numThreads;
     }
     return 1;
   }
 
   UInt32 Get_BZip2_BlockSize() const
   {
-    const int i = FindProp(NCoderPropID::kDictionarySize);
+    int i = FindProp(NCoderPropID::kDictionarySize);
     if (i >= 0)
-    {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
-      if (val.vt == VT_UI4)
+      if (Props[i].Value.vt == VT_UI4)
       {
-        UInt32 blockSize = val.ulVal;
+        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;
       }
-    }
-    const unsigned level = GetLevel();
+    int level = GetLevel();
     return 100000 * (level >= 5 ? 9 : (level >= 1 ? level * 2 - 1: 1));
   }
 
-  UInt64 Get_Ppmd_MemSize() const
+  UInt32 Get_Ppmd_MemSize() const
   {
-    const int i = FindProp(NCoderPropID::kUsedMemorySize);
+    int i = FindProp(NCoderPropID::kUsedMemorySize);
     if (i >= 0)
-    {
-      const NWindows::NCOM::CPropVariant &val = Props[(unsigned)i].Value;
-      if (val.vt == VT_UI4)
-        return val.ulVal;
-      if (val.vt == VT_UI8)
-        return val.uhVal.QuadPart;
-    }
-    const unsigned level = GetLevel();
-    const UInt32 mem = (UInt32)1 << (level + 19);
-    return mem;
+      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)
@@ -314,17 +240,6 @@ public:
       AddPropBool(NCoderPropID::kEndMarker, eos);
   }
 
-  void AddProp_BlockSize2(UInt64 blockSize2)
-  {
-    if (FindProp(NCoderPropID::kBlockSize2) < 0)
-    {
-      CProp &prop = Props.AddNew();
-      prop.IsOptional = true;
-      prop.Id = NCoderPropID::kBlockSize2;
-      prop.Value = blockSize2;
-    }
-  }
-
   HRESULT ParseParamsFromString(const UString &srcString);
   HRESULT ParseParamsFromPROPVARIANT(const UString &realName, const PROPVARIANT &value);
 };

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/OffsetStream.cpp

@@ -2,36 +2,38 @@
 
 #include "StdAfx.h"
 
+#include "../../Common/Defs.h"
+
 #include "OffsetStream.h"
 
 HRESULT COffsetOutStream::Init(IOutStream *stream, UInt64 offset)
 {
   _offset = offset;
   _stream = stream;
-  return _stream->Seek((Int64)offset, STREAM_SEEK_SET, NULL);
+  return _stream->Seek(offset, STREAM_SEEK_SET, NULL);
 }
 
-Z7_COM7F_IMF(COffsetOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP COffsetOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   return _stream->Write(data, size, processedSize);
 }
 
-Z7_COM7F_IMF(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;
   }
-  UInt64 absoluteNewPosition = 0; // =0 for gcc-10
-  const HRESULT result = _stream->Seek(offset, seekOrigin, &absoluteNewPosition);
+  HRESULT result = _stream->Seek(offset, seekOrigin, &absoluteNewPosition);
   if (newPosition)
     *newPosition = absoluteNewPosition - _offset;
   return result;
 }
 
-Z7_COM7F_IMF(COffsetOutStream::SetSize(UInt64 newSize))
+STDMETHODIMP COffsetOutStream::SetSize(UInt64 newSize)
 {
   return _stream->SetSize(_offset + newSize);
 }

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/OffsetStream.h

@@ -1,22 +1,26 @@
 // OffsetStream.h
 
-#ifndef ZIP7_INC_OFFSET_STREAM_H
-#define ZIP7_INC_OFFSET_STREAM_H
+#ifndef __OFFSET_STREAM_H
+#define __OFFSET_STREAM_H
 
 #include "../../Common/MyCom.h"
 
 #include "../IStream.h"
 
-Z7_CLASS_IMP_NOQIB_1(
-  COffsetOutStream
-  , IOutStream
-)
-  Z7_IFACE_COM7_IMP(ISequentialOutStream)
-
-  CMyComPtr<IOutStream> _stream;
+class COffsetOutStream:
+  public IOutStream,
+  public CMyUnknownImp
+{
   UInt64 _offset;
+  CMyComPtr<IOutStream> _stream;
 public:
   HRESULT Init(IOutStream *stream, UInt64 offset);
+  
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+  STDMETHOD(SetSize)(UInt64 newSize);
 };
 
 #endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/OutBuffer.cpp

@@ -11,18 +11,18 @@ bool COutBuffer::Create(UInt32 bufSize) throw()
   const UInt32 kMinBlockSize = 1;
   if (bufSize < kMinBlockSize)
     bufSize = kMinBlockSize;
-  if (_buf && _bufSize == bufSize)
+  if (_buf != 0 && _bufSize == bufSize)
     return true;
   Free();
   _bufSize = bufSize;
   _buf = (Byte *)::MidAlloc(bufSize);
-  return (_buf != NULL);
+  return (_buf != 0);
 }
 
 void COutBuffer::Free() throw()
 {
   ::MidFree(_buf);
-  _buf = NULL;
+  _buf = 0;
 }
 
 void COutBuffer::Init() throw()
@@ -32,7 +32,7 @@ void COutBuffer::Init() throw()
   _pos = 0;
   _processedSize = 0;
   _overDict = false;
-  #ifdef Z7_NO_EXCEPTIONS
+  #ifdef _NO_EXCEPTIONS
   ErrorCode = S_OK;
   #endif
 }
@@ -51,17 +51,17 @@ HRESULT COutBuffer::FlushPart() throw()
   // _streamPos < _bufSize
   UInt32 size = (_streamPos >= _pos) ? (_bufSize - _streamPos) : (_pos - _streamPos);
   HRESULT result = S_OK;
-  #ifdef Z7_NO_EXCEPTIONS
+  #ifdef _NO_EXCEPTIONS
   result = ErrorCode;
   #endif
-  if (_buf2)
+  if (_buf2 != 0)
   {
     memcpy(_buf2, _buf + _streamPos, size);
     _buf2 += size;
   }
 
-  if (_stream
-      #ifdef Z7_NO_EXCEPTIONS
+  if (_stream != 0
+      #ifdef _NO_EXCEPTIONS
       && (ErrorCode == S_OK)
       #endif
      )
@@ -85,14 +85,14 @@ HRESULT COutBuffer::FlushPart() throw()
 
 HRESULT COutBuffer::Flush() throw()
 {
-  #ifdef Z7_NO_EXCEPTIONS
+  #ifdef _NO_EXCEPTIONS
   if (ErrorCode != S_OK)
     return ErrorCode;
   #endif
 
   while (_streamPos != _pos)
   {
-    const HRESULT result = FlushPart();
+    HRESULT result = FlushPart();
     if (result != S_OK)
       return result;
   }
@@ -101,8 +101,8 @@ HRESULT COutBuffer::Flush() throw()
 
 void COutBuffer::FlushWithCheck()
 {
-  const HRESULT result = Flush();
-  #ifdef Z7_NO_EXCEPTIONS
+  HRESULT result = Flush();
+  #ifdef _NO_EXCEPTIONS
   ErrorCode = result;
   #else
   if (result != S_OK)

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/OutBuffer.h

@@ -1,13 +1,13 @@
 // OutBuffer.h
 
-#ifndef ZIP7_INC_OUT_BUFFER_H
-#define ZIP7_INC_OUT_BUFFER_H
+#ifndef __OUT_BUFFER_H
+#define __OUT_BUFFER_H
 
 #include "../IStream.h"
 #include "../../Common/MyCom.h"
 #include "../../Common/MyException.h"
 
-#ifndef Z7_NO_EXCEPTIONS
+#ifndef _NO_EXCEPTIONS
 struct COutBufferException: public CSystemException
 {
   COutBufferException(HRESULT errorCode): CSystemException(errorCode) {}
@@ -29,11 +29,11 @@ protected:
 
   HRESULT FlushPart() throw();
 public:
-  #ifdef Z7_NO_EXCEPTIONS
+  #ifdef _NO_EXCEPTIONS
   HRESULT ErrorCode;
   #endif
 
-  COutBuffer(): _buf(NULL), _pos(0), _stream(NULL), _buf2(NULL) {}
+  COutBuffer(): _buf(0), _pos(0), _stream(0), _buf2(0) {}
   ~COutBuffer() { Free(); }
   
   bool Create(UInt32 bufSize) throw();
@@ -45,7 +45,6 @@ public:
   HRESULT Flush() throw();
   void FlushWithCheck();
 
-  Z7_FORCE_INLINE
   void WriteByte(Byte b)
   {
     UInt32 pos = _pos;
@@ -55,77 +54,11 @@ public:
     if (pos == _limitPos)
       FlushWithCheck();
   }
-  
   void WriteBytes(const void *data, size_t size)
   {
-    while (size)
-    {
-      UInt32 pos = _pos;
-      size_t cur = (size_t)(_limitPos - pos);
-      if (cur >= size)
-        cur = size;
-      size -= cur;
-      Byte *dest = _buf + pos;
-      pos += (UInt32)cur;
-      _pos = pos;
-#if 0
-      memcpy(dest, data, cur);
-      data = (const void *)((const Byte *)data + cur);
-#else
-      const Byte * const lim = (const Byte *)data + cur;
-      do
-      {
-        *dest++ = *(const Byte *)data;
-        data = (const void *)((const Byte *)data + 1);
-      }
-      while (data != lim);
-#endif
-      if (pos == _limitPos)
-        FlushWithCheck();
-    }
-  }
-
-  Byte *GetOutBuffer(size_t &avail)
-  {
-    const UInt32 pos = _pos;
-    avail = (size_t)(_limitPos - pos);
-    return _buf + pos;
-  }
-
-  void SkipWrittenBytes(size_t num)
-  {
-    const UInt32 pos = _pos;
-    const UInt32 rem = _limitPos - pos;
-    if (rem > num)
-    {
-      _pos = pos + (UInt32)num;
-      return;
-    }
-    // (rem <= num)
-    // the caller must not call it with (rem < num)
-    // so (rem == num)
-    _pos = _limitPos;
-    FlushWithCheck();
-  }
-  /*
-  void WriteBytesBig(const void *data, size_t size)
-  {
-    while (size)
-    {
-      UInt32 pos = _pos;
-      UInt32 rem = _limitPos - pos;
-      if (rem > size)
-      {
-        _pos = pos + size;
-        memcpy(_buf + pos, data, size);
-        return;
-      }
-      memcpy(_buf + pos, data, rem);
-      _pos = pos + rem;
-      FlushWithCheck();
-    }
+    for (size_t i = 0; i < size; i++)
+      WriteByte(((const Byte *)data)[i]);
   }
-  */
 
   UInt64 GetProcessedSize() const throw();
 };

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/ProgressUtils.cpp

@@ -5,11 +5,11 @@
 #include "ProgressUtils.h"
 
 CLocalProgress::CLocalProgress():
-    SendRatio(true),
-    SendProgress(true),
     ProgressOffset(0),
     InSize(0),
-    OutSize(0)
+    OutSize(0),
+    SendRatio(true),
+    SendProgress(true)
   {}
 
 void CLocalProgress::Init(IProgress *progress, bool inSizeIsMain)
@@ -20,7 +20,7 @@ void CLocalProgress::Init(IProgress *progress, bool inSizeIsMain)
   _inSizeIsMain = inSizeIsMain;
 }
 
-Z7_COM7F_IMF(CLocalProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize))
+STDMETHODIMP CLocalProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
 {
   UInt64 inSize2 = InSize;
   UInt64 outSize2 = OutSize;
@@ -32,7 +32,7 @@ Z7_COM7F_IMF(CLocalProgress::SetRatioInfo(const UInt64 *inSize, const UInt64 *ou
   
   if (SendRatio && _ratioProgress)
   {
-    RINOK(_ratioProgress->SetRatioInfo(&inSize2, &outSize2))
+    RINOK(_ratioProgress->SetRatioInfo(&inSize2, &outSize2));
   }
   
   if (SendProgress)

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/ProgressUtils.h

@@ -1,33 +1,35 @@
 // ProgressUtils.h
 
-#ifndef ZIP7_INC_PROGRESS_UTILS_H
-#define ZIP7_INC_PROGRESS_UTILS_H
+#ifndef __PROGRESS_UTILS_H
+#define __PROGRESS_UTILS_H
 
 #include "../../Common/MyCom.h"
 
 #include "../ICoder.h"
 #include "../IProgress.h"
 
-Z7_CLASS_IMP_COM_1(
-  CLocalProgress
-  , ICompressProgressInfo
-)
-public:
-  bool SendRatio;
-  bool SendProgress;
-private:
-  bool _inSizeIsMain;
+class CLocalProgress:
+  public ICompressProgressInfo,
+  public CMyUnknownImp
+{
   CMyComPtr<IProgress> _progress;
   CMyComPtr<ICompressProgressInfo> _ratioProgress;
+  bool _inSizeIsMain;
 public:
   UInt64 ProgressOffset;
   UInt64 InSize;
   UInt64 OutSize;
+  bool SendRatio;
+  bool SendProgress;
 
   CLocalProgress();
 
   void Init(IProgress *progress, bool inSizeIsMain);
   HRESULT SetCur();
+
+  MY_UNKNOWN_IMP1(ICompressProgressInfo)
+
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
 };
 
 #endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Common/PropId.cpp

@@ -104,14 +104,5 @@ const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED] =
   VT_UI8,
   VT_BOOL,
   VT_BSTR,
-  VT_BSTR,
-  VT_BSTR,
-  VT_BOOL,
-  VT_FILETIME, // kpidChangeTime
-  VT_UI4,
-  VT_UI4,
-  VT_UI4,
-  VT_UI4,
-  VT_UI4,
-  VT_UI4  // kpidDevMinor
+  VT_BSTR
 };