react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/CodecExports.cpp

@@ -3,13 +3,11 @@
 #include "StdAfx.h"
 
 #include "../../../C/CpuArch.h"
-#include "../../../C/7zVersion.h"
 
 #include "../../Common/ComTry.h"
 #include "../../Common/MyCom.h"
 
 #include "../../Windows/Defs.h"
-#include "../../Windows/PropVariant.h"
 
 #include "../ICoder.h"
 
@@ -23,7 +21,7 @@ extern const CHasherInfo *g_Hashers[];
 
 static void SetPropFromAscii(const char *s, PROPVARIANT *prop) throw()
 {
-  const UINT len = (UINT)strlen(s);
+  UINT len = (UINT)strlen(s);
   BSTR dest = ::SysAllocStringLen(NULL, len);
   if (dest)
   {
@@ -47,7 +45,7 @@ static HRESULT MethodToClassID(UInt16 typeId, CMethodId id, PROPVARIANT *value)
   clsId.Data1 = k_7zip_GUID_Data1;
   clsId.Data2 = k_7zip_GUID_Data2;
   clsId.Data3 = typeId;
-  SetUi64(clsId.Data4, id)
+  SetUi64(clsId.Data4, id);
   return SetPropGUID(clsId, value);
 }
 
@@ -63,7 +61,7 @@ static HRESULT FindCodecClassId(const GUID *clsid, bool isCoder2, bool isFilter,
        if (clsid->Data3 == k_7zip_GUID_Data3_Decoder) encode = false;
   else if (clsid->Data3 != k_7zip_GUID_Data3_Encoder) return S_OK;
   
-  const UInt64 id = GetUi64(clsid->Data4);
+  UInt64 id = GetUi64(clsid->Data4);
   
   for (unsigned i = 0; i < g_NumCodecs; i++)
   {
@@ -77,21 +75,13 @@ static HRESULT FindCodecClassId(const GUID *clsid, bool isCoder2, bool isFilter,
     if (codec.NumStreams == 1 ? isCoder2 : !isCoder2)
       return E_NOINTERFACE;
     
-    index = (int)i;
+    index = i;
     return S_OK;
   }
   
   return S_OK;
 }
 
-/*
-#ifdef __GNUC__
-#ifndef __clang__
-#pragma GCC diagnostic ignored "-Wduplicated-branches"
-#endif
-#endif
-*/
-
 static HRESULT CreateCoderMain(unsigned index, bool encode, void **coder)
 {
   COM_TRY_BEGIN
@@ -107,15 +97,12 @@ static HRESULT CreateCoderMain(unsigned index, bool encode, void **coder)
   if (c)
   {
     IUnknown *unk;
-    unk = (IUnknown *)c;
-    /*
     if (codec.IsFilter)
       unk = (IUnknown *)(ICompressFilter *)c;
     else if (codec.NumStreams != 1)
       unk = (IUnknown *)(ICompressCoder2 *)c;
     else
       unk = (IUnknown *)(ICompressCoder *)c;
-    */
     unk->AddRef();
     *coder = c;
   }
@@ -149,29 +136,23 @@ static HRESULT CreateCoder2(bool encode, UInt32 index, const GUID *iid, void **o
   return CreateCoderMain(index, encode, outObject);
 }
 
-
-STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject);
 STDAPI CreateDecoder(UInt32 index, const GUID *iid, void **outObject)
 {
   return CreateCoder2(false, index, iid, outObject);
 }
 
-
-STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject);
 STDAPI CreateEncoder(UInt32 index, const GUID *iid, void **outObject)
 {
   return CreateCoder2(true, index, iid, outObject);
 }
 
-
-STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject);
 STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
 {
   *outObject = NULL;
 
   bool isFilter = false;
   bool isCoder2 = false;
-  const bool isCoder = (*iid == IID_ICompressCoder) != 0;
+  bool isCoder = (*iid == IID_ICompressCoder) != 0;
   if (!isCoder)
   {
     isFilter = (*iid == IID_ICompressFilter) != 0;
@@ -185,17 +166,15 @@ STDAPI CreateCoder(const GUID *clsid, const GUID *iid, void **outObject)
   
   bool encode;
   int codecIndex;
-  const HRESULT res = FindCodecClassId(clsid, isCoder2, isFilter, encode, codecIndex);
+  HRESULT res = FindCodecClassId(clsid, isCoder2, isFilter, encode, codecIndex);
   if (res != S_OK)
     return res;
   if (codecIndex < 0)
     return CLASS_E_CLASSNOTAVAILABLE;
 
-  return CreateCoderMain((unsigned)codecIndex, encode, outObject);
+  return CreateCoderMain(codecIndex, encode, outObject);
 }
  
-
-STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
 STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
 {
   ::VariantClear((VARIANTARG *)value);
@@ -232,12 +211,15 @@ STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
         value->ulVal = (ULONG)codec.NumStreams;
       }
       break;
+    /*
     case NMethodPropID::kIsFilter:
+      // if (codec.IsFilter)
       {
         value->vt = VT_BOOL;
         value->boolVal = BoolToVARIANT_BOOL(codec.IsFilter);
       }
       break;
+    */
     /*
     case NMethodPropID::kDecoderFlags:
       {
@@ -256,9 +238,7 @@ STDAPI GetMethodProperty(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
   return S_OK;
 }
 
-
-STDAPI GetNumberOfMethods(UInt32 *numCodecs);
-STDAPI GetNumberOfMethods(UInt32 *numCodecs)
+STDAPI GetNumberOfMethods(UINT32 *numCodecs)
 {
   *numCodecs = g_NumCodecs;
   return S_OK;
@@ -273,10 +253,10 @@ static int FindHasherClassId(const GUID *clsid) throw()
       clsid->Data2 != k_7zip_GUID_Data2 ||
       clsid->Data3 != k_7zip_GUID_Data3_Hasher)
     return -1;
-  const UInt64 id = GetUi64(clsid->Data4);
+  UInt64 id = GetUi64(clsid->Data4);
   for (unsigned i = 0; i < g_NumCodecs; i++)
     if (id == g_Hashers[i]->Id)
-      return (int)i;
+      return i;
   return -1;
 }
 
@@ -290,19 +270,17 @@ static HRESULT CreateHasher2(UInt32 index, IHasher **hasher)
   COM_TRY_END
 }
 
-STDAPI CreateHasher(const GUID *clsid, IHasher **outObject);
 STDAPI CreateHasher(const GUID *clsid, IHasher **outObject)
 {
   COM_TRY_BEGIN
-  *outObject = NULL;
-  const int index = FindHasherClassId(clsid);
+  *outObject = 0;
+  int index = FindHasherClassId(clsid);
   if (index < 0)
     return CLASS_E_CLASSNOTAVAILABLE;
-  return CreateHasher2((UInt32)(unsigned)index, outObject);
+  return CreateHasher2(index, outObject);
   COM_TRY_END
 }
 
-STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
 STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
 {
   ::VariantClear((VARIANTARG *)value);
@@ -328,9 +306,18 @@ STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value)
   return S_OK;
 }
 
-Z7_CLASS_IMP_COM_1(CHashers, IHashers) };
+class CHashers:
+  public IHashers,
+  public CMyUnknownImp
+{
+public:
+  MY_UNKNOWN_IMP1(IHashers)
+
+  STDMETHOD_(UInt32, GetNumHashers)();
+  STDMETHOD(GetHasherProp)(UInt32 index, PROPID propID, PROPVARIANT *value);
+  STDMETHOD(CreateHasher)(UInt32 index, IHasher **hasher);
+};
 
-STDAPI GetHashers(IHashers **hashers);
 STDAPI GetHashers(IHashers **hashers)
 {
   COM_TRY_BEGIN
@@ -341,38 +328,17 @@ STDAPI GetHashers(IHashers **hashers)
   COM_TRY_END
 }
 
-Z7_COM7F_IMF2(UInt32, CHashers::GetNumHashers())
+STDMETHODIMP_(UInt32) CHashers::GetNumHashers()
 {
   return g_NumHashers;
 }
 
-Z7_COM7F_IMF(CHashers::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CHashers::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   return ::GetHasherProp(index, propID, value);
 }
 
-Z7_COM7F_IMF(CHashers::CreateHasher(UInt32 index, IHasher **hasher))
+STDMETHODIMP CHashers::CreateHasher(UInt32 index, IHasher **hasher)
 {
   return ::CreateHasher2(index, hasher);
 }
-
-
-STDAPI GetModuleProp(PROPID propID, PROPVARIANT *value);
-STDAPI GetModuleProp(PROPID propID, PROPVARIANT *value)
-{
-  ::VariantClear((VARIANTARG *)value);
-  switch (propID)
-  {
-    case NModulePropID::kInterfaceType:
-    {
-      NWindows::NCOM::PropVarEm_Set_UInt32(value, NModuleInterfaceType::k_IUnknown_VirtDestructor_ThisModule);
-      break;
-    }
-    case NModulePropID::kVersion:
-    {
-      NWindows::NCOM::PropVarEm_Set_UInt32(value, (MY_VER_MAJOR << 16) | MY_VER_MINOR);
-      break;
-    }
-  }
-  return S_OK;
-}

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/CopyCoder.cpp

@@ -15,15 +15,15 @@ CCopyCoder::~CCopyCoder()
   ::MidFree(_buf);
 }
 
-Z7_COM7F_IMF(CCopyCoder::SetFinishMode(UInt32 /* finishMode */))
+STDMETHODIMP CCopyCoder::SetFinishMode(UInt32 /* finishMode */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CCopyCoder::Code(ISequentialInStream *inStream,
+STDMETHODIMP CCopyCoder::Code(ISequentialInStream *inStream,
     ISequentialOutStream *outStream,
     const UInt64 * /* inSize */, const UInt64 *outSize,
-    ICompressProgressInfo *progress))
+    ICompressProgressInfo *progress)
 {
   if (!_buf)
   {
@@ -37,39 +37,12 @@ Z7_COM7F_IMF(CCopyCoder::Code(ISequentialInStream *inStream,
   for (;;)
   {
     UInt32 size = kBufSize;
-    if (outSize)
-    {
-      const UInt64 rem = *outSize - TotalSize;
-      if (size > rem)
-      {
-        size = (UInt32)rem;
-        if (size == 0)
-        {
-          /* if we enable the following check,
-             we will make one call of Read(_buf, 0) for empty stream */
-          // if (TotalSize != 0)
-          return S_OK;
-        }
-      }
-    }
+    if (outSize && size > *outSize - TotalSize)
+      size = (UInt32)(*outSize - TotalSize);
+    if (size == 0)
+      return S_OK;
     
-    HRESULT readRes;
-    {
-      UInt32 pos = 0;
-      do
-      {
-        const UInt32 curSize = size - pos;
-        UInt32 processed = 0;
-        readRes = inStream->Read(_buf + pos, curSize, &processed);
-        if (processed > curSize)
-          return E_FAIL; // internal code failure
-        pos += processed;
-        if (readRes != S_OK || processed == 0)
-          break;
-      }
-      while (pos < kBufSize);
-      size = pos;
-    }
+    HRESULT readRes = inStream->Read(_buf, size, &size);
 
     if (size == 0)
       return readRes;
@@ -79,15 +52,12 @@ Z7_COM7F_IMF(CCopyCoder::Code(ISequentialInStream *inStream,
       UInt32 pos = 0;
       do
       {
-        const UInt32 curSize = size - pos;
-        UInt32 processed = 0;
-        const HRESULT res = outStream->Write(_buf + pos, curSize, &processed);
-        if (processed > curSize)
-          return E_FAIL; // internal code failure
-        pos += processed;
-        TotalSize += processed;
-        RINOK(res)
-        if (processed == 0)
+        UInt32 curSize = size - pos;
+        HRESULT res = outStream->Write(_buf + pos, curSize, &curSize);
+        pos += curSize;
+        TotalSize += curSize;
+        RINOK(res);
+        if (curSize == 0)
           return E_FAIL;
       }
       while (pos < size);
@@ -95,32 +65,29 @@ Z7_COM7F_IMF(CCopyCoder::Code(ISequentialInStream *inStream,
     else
       TotalSize += size;
 
-    RINOK(readRes)
-
-    if (size != kBufSize)
-      return S_OK;
+    RINOK(readRes);
 
-    if (progress && (TotalSize & (((UInt32)1 << 22) - 1)) == 0)
+    if (progress)
     {
-      RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize))
+      RINOK(progress->SetRatioInfo(&TotalSize, &TotalSize));
     }
   }
 }
 
-Z7_COM7F_IMF(CCopyCoder::SetInStream(ISequentialInStream *inStream))
+STDMETHODIMP CCopyCoder::SetInStream(ISequentialInStream *inStream)
 {
   _inStream = inStream;
   TotalSize = 0;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CCopyCoder::ReleaseInStream())
+STDMETHODIMP CCopyCoder::ReleaseInStream()
 {
   _inStream.Release();
   return S_OK;
 }
 
-Z7_COM7F_IMF(CCopyCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CCopyCoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 realProcessedSize = 0;
   HRESULT res = _inStream->Read(data, size, &realProcessedSize);
@@ -130,7 +97,7 @@ Z7_COM7F_IMF(CCopyCoder::Read(void *data, UInt32 size, UInt32 *processedSize))
   return res;
 }
 
-Z7_COM7F_IMF(CCopyCoder::GetInStreamProcessedSize(UInt64 *value))
+STDMETHODIMP CCopyCoder::GetInStreamProcessedSize(UInt64 *value)
 {
   *value = TotalSize;
   return S_OK;
@@ -146,7 +113,7 @@ HRESULT CopyStream_ExactSize(ISequentialInStream *inStream, ISequentialOutStream
 {
   NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
   CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-  RINOK(copyCoder->Code(inStream, outStream, NULL, &size, progress))
+  RINOK(copyCoder->Code(inStream, outStream, NULL, &size, progress));
   return copyCoderSpec->TotalSize == size ? S_OK : E_FAIL;
 }
 

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/CopyCoder.h

@@ -1,7 +1,7 @@
 // Compress/CopyCoder.h
 
-#ifndef ZIP7_INC_COMPRESS_COPY_CODER_H
-#define ZIP7_INC_COMPRESS_COPY_CODER_H
+#ifndef __COMPRESS_COPY_CODER_H
+#define __COMPRESS_COPY_CODER_H
 
 #include "../../Common/MyCom.h"
 
@@ -9,21 +9,36 @@
 
 namespace NCompress {
 
-Z7_CLASS_IMP_COM_5(
-  CCopyCoder
-  , ICompressCoder
-  , ICompressSetInStream
-  , ISequentialInStream
-  , ICompressSetFinishMode
-  , ICompressGetInStreamProcessedSize
-)
+class CCopyCoder:
+  public ICompressCoder,
+  public ICompressSetInStream,
+  public ISequentialInStream,
+  public ICompressSetFinishMode,
+  public ICompressGetInStreamProcessedSize,
+  public CMyUnknownImp
+{
   Byte *_buf;
   CMyComPtr<ISequentialInStream> _inStream;
 public:
   UInt64 TotalSize;
   
-  CCopyCoder(): _buf(NULL), TotalSize(0) {}
+  CCopyCoder(): _buf(0), TotalSize(0) {};
   ~CCopyCoder();
+
+  MY_UNKNOWN_IMP5(
+      ICompressCoder,
+      ICompressSetInStream,
+      ISequentialInStream,
+      ICompressSetFinishMode,
+      ICompressGetInStreamProcessedSize)
+
+  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(SetFinishMode)(UInt32 finishMode);
+  STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
 };
 
 HRESULT CopyStream(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/DeltaFilter.cpp

@@ -23,40 +23,41 @@ struct CDelta
 };
 
 
-#ifndef Z7_EXTRACT_ONLY
+#ifndef EXTRACT_ONLY
 
-class CEncoder Z7_final:
+class CEncoder:
   public ICompressFilter,
   public ICompressSetCoderProperties,
   public ICompressWriteCoderProperties,
-  public CMyUnknownImp,
-  CDelta
+  CDelta,
+  public CMyUnknownImp
 {
-  Z7_IFACES_IMP_UNK_3(
-      ICompressFilter,
-      ICompressSetCoderProperties,
-      ICompressWriteCoderProperties)
+public:
+  MY_UNKNOWN_IMP3(ICompressFilter, ICompressSetCoderProperties, ICompressWriteCoderProperties)
+  INTERFACE_ICompressFilter(;)
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
 };
 
-Z7_COM7F_IMF(CEncoder::Init())
+STDMETHODIMP CEncoder::Init()
 {
   DeltaInit();
   return S_OK;
 }
 
-Z7_COM7F_IMF2(UInt32, CEncoder::Filter(Byte *data, UInt32 size))
+STDMETHODIMP_(UInt32) CEncoder::Filter(Byte *data, UInt32 size)
 {
   Delta_Encode(_state, _delta, data, size);
   return size;
 }
 
-Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps))
+STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps)
 {
-  unsigned delta = _delta;
+  UInt32 delta = _delta;
   for (UInt32 i = 0; i < numProps; i++)
   {
     const PROPVARIANT &prop = props[i];
-    const PROPID propID = propIDs[i];
+    PROPID propID = propIDs[i];
     if (propID >= NCoderPropID::kReduceSize)
       continue;
     if (prop.vt != VT_UI4)
@@ -64,9 +65,9 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
     switch (propID)
     {
       case NCoderPropID::kDefaultProp:
-        if (prop.ulVal < 1 || prop.ulVal > 256)
+        delta = (UInt32)prop.ulVal;
+        if (delta < 1 || delta > 256)
           return E_INVALIDARG;
-        delta = prop.ulVal;
         break;
       case NCoderPropID::kNumThreads: break;
       case NCoderPropID::kLevel: break;
@@ -77,39 +78,40 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
   return S_OK;
 }
 
-Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
 {
-  const Byte prop = (Byte)(_delta - 1);
+  Byte prop = (Byte)(_delta - 1);
   return outStream->Write(&prop, 1, NULL);
 }
 
 #endif
 
 
-class CDecoder Z7_final:
+class CDecoder:
   public ICompressFilter,
   public ICompressSetDecoderProperties2,
-  public CMyUnknownImp,
-  CDelta
+  CDelta,
+  public CMyUnknownImp
 {
-  Z7_IFACES_IMP_UNK_2(
-      ICompressFilter,
-      ICompressSetDecoderProperties2)
+public:
+  MY_UNKNOWN_IMP2(ICompressFilter, ICompressSetDecoderProperties2)
+  INTERFACE_ICompressFilter(;)
+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
 };
 
-Z7_COM7F_IMF(CDecoder::Init())
+STDMETHODIMP CDecoder::Init()
 {
   DeltaInit();
   return S_OK;
 }
 
-Z7_COM7F_IMF2(UInt32, CDecoder::Filter(Byte *data, UInt32 size))
+STDMETHODIMP_(UInt32) CDecoder::Filter(Byte *data, UInt32 size)
 {
   Delta_Decode(_state, _delta, data, size);
   return size;
 }
 
-Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size))
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
 {
   if (size != 1)
     return E_INVALIDARG;