react-native-update 10.34.3 → 10.34.4

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

@@ -1,7 +1,7 @@
 // CoderMixer2.h
 
-#ifndef ZIP7_INC_CODER_MIXER2_H
-#define ZIP7_INC_CODER_MIXER2_H
+#ifndef __CODER_MIXER2_H
+#define __CODER_MIXER2_H
 
 #include "../../../Common/MyCom.h"
 #include "../../../Common/MyVector.h"
@@ -10,11 +10,11 @@
 
 #include "../../Common/CreateCoder.h"
 
-#ifdef Z7_ST
+#ifdef _7ZIP_ST
   #define USE_MIXER_ST
 #else
   #define USE_MIXER_MT
-  #ifndef Z7_SFX
+  #ifndef _SFX
     #define USE_MIXER_ST
   #endif
 #endif
@@ -28,13 +28,18 @@
 
 #ifdef USE_MIXER_ST
 
-Z7_CLASS_IMP_COM_1(
-  CSequentialInStreamCalcSize
-  , ISequentialInStream
-)
-  bool _wasFinished;
+class CSequentialInStreamCalcSize:
+  public ISequentialInStream,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1(ISequentialInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+private:
   CMyComPtr<ISequentialInStream> _stream;
   UInt64 _size;
+  bool _wasFinished;
 public:
   void SetStream(ISequentialInStream *stream) { _stream = stream;  }
   void Init()
@@ -48,14 +53,19 @@ public:
 };
 
 
-Z7_CLASS_IMP_COM_2(
-  COutStreamCalcSize
-  , ISequentialOutStream
-  , IOutStreamFinish
-)
+class COutStreamCalcSize:
+  public ISequentialOutStream,
+  public IOutStreamFinish,
+  public CMyUnknownImp
+{
   CMyComPtr<ISequentialOutStream> _stream;
   UInt64 _size;
 public:
+  MY_UNKNOWN_IMP2(ISequentialOutStream, IOutStreamFinish)
+  
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(OutStreamFinish)();
+  
   void SetStream(ISequentialOutStream *stream) { _stream = stream; }
   void ReleaseStream() { _stream.Release(); }
   void Init() { _size = 0; }
@@ -97,7 +107,7 @@ struct CBindInfo
   {
     FOR_VECTOR (i, Bonds)
       if (Bonds[i].PackIndex == packStream)
-        return (int)i;
+        return i;
     return -1;
   }
 
@@ -105,14 +115,14 @@ struct CBindInfo
   {
     FOR_VECTOR (i, Bonds)
       if (Bonds[i].UnpackIndex == unpackStream)
-        return (int)i;
+        return i;
     return -1;
   }
 
   bool SetUnpackCoder()
   {
     bool isOk = false;
-    FOR_VECTOR (i, Coders)
+    FOR_VECTOR(i, Coders)
     {
       if (FindBond_for_UnpackStream(i) < 0)
       {
@@ -132,9 +142,9 @@ struct CBindInfo
 
   int FindStream_in_PackStreams(UInt32 streamIndex) const
   {
-    FOR_VECTOR (i, PackStreams)
+    FOR_VECTOR(i, PackStreams)
       if (PackStreams[i] == streamIndex)
-        return (int)i;
+        return i;
     return -1;
   }
 
@@ -179,12 +189,11 @@ struct CBindInfo
 
 class CCoder
 {
-  Z7_CLASS_NO_COPY(CCoder)
+  CLASS_NO_COPY(CCoder);
 public:
   CMyComPtr<ICompressCoder> Coder;
   CMyComPtr<ICompressCoder2> Coder2;
   UInt32 NumStreams;
-  bool Finish;
 
   UInt64 UnpackSize;
   const UInt64 *UnpackSizePointer;
@@ -192,6 +201,8 @@ public:
   CRecordVector<UInt64> PackSizes;
   CRecordVector<const UInt64 *> PackSizePointers;
 
+  bool Finish;
+
   CCoder(): Finish(false) {}
 
   void SetCoderInfo(const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish);
@@ -240,7 +251,6 @@ public:
       // , InternalPackSizeError(false)
       {}
 
-  virtual ~CMixer() {}
   /*
   Sequence of calling:
 
@@ -269,7 +279,7 @@ public:
   virtual void AddCoder(const CCreatedCoder &cod) = 0;
   virtual CCoder &GetCoder(unsigned index) = 0;
   virtual void SelectMainCoder(bool useFirst) = 0;
-  virtual HRESULT ReInit2() = 0;
+  virtual void ReInit() = 0;
   virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish) = 0;
   virtual HRESULT Code(
       ISequentialInStream * const *inStreams,
@@ -312,9 +322,6 @@ class CMixerST:
   public CMixer,
   public CMyUnknownImp
 {
-  Z7_COM_UNKNOWN_IMP_0
-  Z7_CLASS_NO_COPY(CMixerST)
-
   HRESULT GetInStream2(ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
       UInt32 outStreamIndex, ISequentialInStream **inStreamRes);
   HRESULT GetInStream(ISequentialInStream * const *inStreams, /* const UInt64 * const *inSizes, */
@@ -330,21 +337,23 @@ public:
   
   CObjectVector<CStBinderStream> _binderStreams;
 
+  MY_UNKNOWN_IMP
+
   CMixerST(bool encodeMode);
-  ~CMixerST() Z7_DESTRUCTOR_override;
+  ~CMixerST();
 
-  virtual void AddCoder(const CCreatedCoder &cod) Z7_override;
-  virtual CCoder &GetCoder(unsigned index) Z7_override;
-  virtual void SelectMainCoder(bool useFirst) Z7_override;
-  virtual HRESULT ReInit2() Z7_override;
-  virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish) Z7_override
+  virtual void AddCoder(const CCreatedCoder &cod);
+  virtual CCoder &GetCoder(unsigned index);
+  virtual void SelectMainCoder(bool useFirst);
+  virtual void ReInit();
+  virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish)
     { _coders[coderIndex].SetCoderInfo(unpackSize, packSizes, finish); }
   virtual HRESULT Code(
       ISequentialInStream * const *inStreams,
       ISequentialOutStream * const *outStreams,
       ICompressProgressInfo *progress,
-      bool &dataAfterEnd_Error) Z7_override;
-  virtual UInt64 GetBondStreamSize(unsigned bondIndex) const Z7_override;
+      bool &dataAfterEnd_Error);
+  virtual UInt64 GetBondStreamSize(unsigned bondIndex) const;
 
   HRESULT GetMainUnpackStream(
       ISequentialInStream * const *inStreams,
@@ -360,12 +369,12 @@ public:
 
 class CCoderMT: public CCoder, public CVirtThread
 {
-  Z7_CLASS_NO_COPY(CCoderMT)
+  CLASS_NO_COPY(CCoderMT)
   CRecordVector<ISequentialInStream*> InStreamPointers;
   CRecordVector<ISequentialOutStream*> OutStreamPointers;
 
 private:
-  virtual void Execute() Z7_override;
+  void Execute();
 public:
   bool EncodeMode;
   HRESULT Result;
@@ -385,7 +394,7 @@ public:
 
   class CReleaser
   {
-    Z7_CLASS_NO_COPY(CReleaser)
+    CLASS_NO_COPY(CReleaser)
     CCoderMT &_c;
   public:
     CReleaser(CCoderMT &c): _c(c) {}
@@ -393,14 +402,7 @@ public:
   };
 
   CCoderMT(): EncodeMode(false) {}
-  ~CCoderMT() Z7_DESTRUCTOR_override
-  {
-    /* WaitThreadFinish() will be called in ~CVirtThread().
-       But we need WaitThreadFinish() call before CCoder destructor,
-       and before destructors of this class members.
-    */
-    CVirtThread::WaitThreadFinish();
-  }
+  ~CCoderMT() { CVirtThread::WaitThreadFinish(); }
   
   void Code(ICompressProgressInfo *progress);
 };
@@ -411,31 +413,29 @@ class CMixerMT:
   public CMixer,
   public CMyUnknownImp
 {
-  Z7_COM_UNKNOWN_IMP_0
-  Z7_CLASS_NO_COPY(CMixerMT)
-
   CObjectVector<CStreamBinder> _streamBinders;
 
   HRESULT Init(ISequentialInStream * const *inStreams, ISequentialOutStream * const *outStreams);
   HRESULT ReturnIfError(HRESULT code);
 
-  // virtual ~CMixerMT() {}
 public:
   CObjectVector<CCoderMT> _coders;
 
-  virtual HRESULT SetBindInfo(const CBindInfo &bindInfo) Z7_override;
-  virtual void AddCoder(const CCreatedCoder &cod) Z7_override;
-  virtual CCoder &GetCoder(unsigned index) Z7_override;
-  virtual void SelectMainCoder(bool useFirst) Z7_override;
-  virtual HRESULT ReInit2() Z7_override;
-  virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish) Z7_override
+  MY_UNKNOWN_IMP
+
+  virtual HRESULT SetBindInfo(const CBindInfo &bindInfo);
+  virtual void AddCoder(const CCreatedCoder &cod);
+  virtual CCoder &GetCoder(unsigned index);
+  virtual void SelectMainCoder(bool useFirst);
+  virtual void ReInit();
+  virtual void SetCoderInfo(unsigned coderIndex, const UInt64 *unpackSize, const UInt64 * const *packSizes, bool finish)
     { _coders[coderIndex].SetCoderInfo(unpackSize, packSizes, finish); }
   virtual HRESULT Code(
       ISequentialInStream * const *inStreams,
       ISequentialOutStream * const *outStreams,
       ICompressProgressInfo *progress,
-      bool &dataAfterEnd_Error) Z7_override;
-  virtual UInt64 GetBondStreamSize(unsigned bondIndex) const Z7_override;
+      bool &dataAfterEnd_Error);
+  virtual UInt64 GetBondStreamSize(unsigned bondIndex) const;
 
   CMixerMT(bool encodeMode): CMixer(encodeMode) {}
 };

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

@@ -4,7 +4,7 @@
 
 #include "DummyOutStream.h"
 
-Z7_COM7F_IMF(CDummyOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CDummyOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 realProcessedSize = size;
   HRESULT res = S_OK;

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

@@ -1,22 +1,24 @@
 // DummyOutStream.h
 
-#ifndef ZIP7_INC_DUMMY_OUT_STREAM_H
-#define ZIP7_INC_DUMMY_OUT_STREAM_H
+#ifndef __DUMMY_OUT_STREAM_H
+#define __DUMMY_OUT_STREAM_H
 
 #include "../../../Common/MyCom.h"
 
 #include "../../IStream.h"
 
-Z7_CLASS_IMP_NOQIB_1(
-  CDummyOutStream
-  , ISequentialOutStream
-)
+class CDummyOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
   CMyComPtr<ISequentialOutStream> _stream;
   UInt64 _size;
 public:
   void SetStream(ISequentialOutStream *outStream) { _stream = outStream; }
   void ReleaseStream() { _stream.Release(); }
   void Init() { _size = 0; }
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   UInt64 GetSize() const { return _size; }
 };
 

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

@@ -4,6 +4,8 @@
 
 #include "../../../Common/StringToInt.h"
 
+#include "../Common/ParseProperties.h"
+
 #include "HandlerOut.h"
 
 namespace NArchive {
@@ -25,30 +27,11 @@ bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsB
   else if (prop.vt != VT_EMPTY)
     return false;
 
-  bool percentMode = false;
-  {
-    const wchar_t c = *s;
-    if (MyCharLower_Ascii(c) == 'p')
-    {
-      percentMode = true;
-      s++;
-    }
-  }
-
   const wchar_t *end;
-  const UInt64 v = ConvertStringToUInt64(s, &end);
+  UInt64 v = ConvertStringToUInt64(s, &end);
   if (s == end)
     return false;
-  const wchar_t c = *end;
-
-  if (percentMode)
-  {
-    if (c != 0)
-      return false;
-    res = Calc_From_Val_Percents(percentsBase, v);
-    return true;
-  }
-
+  wchar_t c = *end;
   if (c == 0)
   {
     res = v;
@@ -59,7 +42,7 @@ bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsB
 
   if (c == '%')
   {
-    res = Calc_From_Val_Percents(percentsBase, v);
+    res = percentsBase / 100 * v;
     return true;
   }
 
@@ -73,37 +56,29 @@ bool ParseSizeString(const wchar_t *s, const PROPVARIANT &prop, UInt64 percentsB
     case 't': numBits = 40; break;
     default: return false;
   }
-  const UInt64 val2 = v << numBits;
+  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 Z7_ST
-    _numThreads = _numProcessors;
-    _numThreads_WasForced = false;
-    hres = ParseMtProp2(name.Ptr(2), value, _numThreads, _numThreads_WasForced);
-    // "mt" means "_numThreads_WasForced = false" here
+    #ifndef _7ZIP_ST
+    hres = ParseMtProp(name.Ptr(2), value, _numProcessors, _numThreads);
     #endif
     return true;
   }
   
   if (name.IsPrefixedBy_Ascii_NoCase("memuse"))
   {
-    UInt64 v;
-    if (!ParseSizeString(name.Ptr(6), value, _memAvail, v))
+    if (!ParseSizeString(name.Ptr(6), value, _memAvail, _memUsage))
       hres = E_INVALIDARG;
-    _memUsage_Decompress = v;
-    _memUsage_Compress = v;
-    _memUsage_WasSet = true;
     return true;
   }
 
@@ -111,9 +86,9 @@ bool CCommonMethodProps::SetCommonProperty(const UString &name, const PROPVARIAN
 }
 
 
-#ifndef Z7_EXTRACT_ONLY
+#ifndef EXTRACT_ONLY
 
-static void SetMethodProp32(CMethodProps &m, PROPID propID, UInt32 value)
+static void SetMethodProp32(COneMethodInfo &m, PROPID propID, UInt32 value)
 {
   if (m.FindProp(propID) < 0)
     m.AddProp32(propID, value);
@@ -126,37 +101,12 @@ void CMultiMethodProps::SetGlobalLevelTo(COneMethodInfo &oneMethodInfo) const
     SetMethodProp32(oneMethodInfo, NCoderPropID::kLevel, (UInt32)level);
 }
 
-#ifndef Z7_ST
-
-static void SetMethodProp32_Replace(CMethodProps &m, PROPID propID, UInt32 value)
-{
-  const int i = m.FindProp(propID);
-  if (i >= 0)
-  {
-    NWindows::NCOM::CPropVariant &val = m.Props[(unsigned)i].Value;
-    val = (UInt32)value;
-    return;
-  }
-  m.AddProp32(propID, value);
-}
-
-void CMultiMethodProps::SetMethodThreadsTo_IfNotFinded(CMethodProps &oneMethodInfo, UInt32 numThreads)
+#ifndef _7ZIP_ST
+void CMultiMethodProps::SetMethodThreadsTo(COneMethodInfo &oneMethodInfo, UInt32 numThreads)
 {
   SetMethodProp32(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
 }
-
-void CMultiMethodProps::SetMethodThreadsTo_Replace(CMethodProps &oneMethodInfo, UInt32 numThreads)
-{
-  SetMethodProp32_Replace(oneMethodInfo, NCoderPropID::kNumThreads, numThreads);
-}
-
-void CMultiMethodProps::Set_Method_NumThreadGroups_IfNotFinded(CMethodProps &oneMethodInfo, UInt32 numThreadGroups)
-{
-  SetMethodProp32(oneMethodInfo, NCoderPropID::kNumThreadGroups, numThreadGroups);
-}
-
-#endif // Z7_ST
-
+#endif
 
 void CMultiMethodProps::InitMulti()
 {
@@ -193,7 +143,7 @@ HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIAN
   {
     name.Delete(0, 2);
     UInt32 v = 9;
-    RINOK(ParsePropToUInt32(name, value, v))
+    RINOK(ParsePropToUInt32(name, value, v));
     _analysisLevel = (int)v;
     return S_OK;
   }
@@ -212,13 +162,13 @@ HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIAN
   }
   
   UInt32 number;
-  const unsigned index = ParseStringToUInt32(name, number);
-  const UString realName = name.Ptr(index);
+  unsigned index = ParseStringToUInt32(name, number);
+  UString realName = name.Ptr(index);
   if (index == 0)
   {
     if (name.IsEqualTo("f"))
     {
-      const HRESULT res = PROPVARIANT_to_bool(value, _autoFilter);
+      HRESULT res = PROPVARIANT_to_bool(value, _autoFilter);
       if (res == S_OK)
         return res;
       if (value.vt != VT_BSTR)
@@ -228,9 +178,9 @@ HRESULT CMultiMethodProps::SetProperty(const wchar_t *nameSpec, const PROPVARIAN
     number = 0;
   }
   if (number > 64)
-    return E_INVALIDARG;
-  for (unsigned j = _methods.Size(); j <= number; j++)
-    _methods.AddNew();
+    return E_FAIL;
+  for (int j = _methods.Size(); j <= (int)number; j++)
+    _methods.Add(COneMethodInfo());
   return _methods[number].ParseMethodFromPROPVARIANT(realName, value);
 }
 
@@ -244,42 +194,34 @@ void CSingleMethodProps::Init()
 }
 
 
-HRESULT CSingleMethodProps::SetProperty(const wchar_t *name2, const PROPVARIANT &value)
-{
-  // processed = false;
-  UString name = name2;
-  name.MakeLower_Ascii();
-  if (name.IsEmpty())
-    return E_INVALIDARG;
-  if (name.IsPrefixedBy_Ascii_NoCase("x"))
-  {
-    UInt32 a = 9;
-    RINOK(ParsePropToUInt32(name.Ptr(1), value, a))
-    _level = a;
-    AddProp_Level(a);
-    // processed = true;
-    return S_OK;
-  }
-  {
-    HRESULT hres;
-    if (SetCommonProperty(name, value, hres))
-    {
-      // processed = true;
-      return S_OK;
-    }
-  }
-  RINOK(ParseMethodFromPROPVARIANT(name, value))
-  return S_OK;
-}
-
-
 HRESULT CSingleMethodProps::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
 {
   Init();
   
   for (UInt32 i = 0; i < numProps; i++)
   {
-    RINOK(SetProperty(names[i], values[i]))
+    UString name = names[i];
+    name.MakeLower_Ascii();
+    if (name.IsEmpty())
+      return E_INVALIDARG;
+    const PROPVARIANT &value = values[i];
+    if (name[0] == L'x')
+    {
+      UInt32 a = 9;
+      RINOK(ParsePropToUInt32(name.Ptr(1), value, a));
+      _level = a;
+      AddProp_Level(a);
+      continue;
+    }
+    {
+      HRESULT hres;
+      if (SetCommonProperty(name, value, hres))
+      {
+        RINOK(hres)
+        continue;
+      }
+    }
+    RINOK(ParseMethodFromPROPVARIANT(names[i], value));
   }
 
   return S_OK;
@@ -287,29 +229,4 @@ HRESULT CSingleMethodProps::SetProperties(const wchar_t * const *names, const PR
 
 #endif
 
-
-static HRESULT PROPVARIANT_to_BoolPair(const PROPVARIANT &prop, CBoolPair &dest)
-{
-  RINOK(PROPVARIANT_to_bool(prop, dest.Val))
-  dest.Def = true;
-  return S_OK;
-}
-
-HRESULT CHandlerTimeOptions::Parse(const UString &name, const PROPVARIANT &prop, bool &processed)
-{
-  processed = true;
-  if (name.IsEqualTo_Ascii_NoCase("tm")) { return PROPVARIANT_to_BoolPair(prop, Write_MTime); }
-  if (name.IsEqualTo_Ascii_NoCase("ta")) { return PROPVARIANT_to_BoolPair(prop, Write_ATime); }
-  if (name.IsEqualTo_Ascii_NoCase("tc")) { return PROPVARIANT_to_BoolPair(prop, Write_CTime); }
-  if (name.IsPrefixedBy_Ascii_NoCase("tp"))
-  {
-    UInt32 v = 0;
-    RINOK(ParsePropToUInt32(name.Ptr(2), prop, v))
-    Prec = v;
-    return S_OK;
-  }
-  processed = false;
-  return S_OK;
-}
-
 }