react-native-update 10.34.3 → 10.34.4

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

@@ -76,30 +76,35 @@ bool CHeader::Parse(const Byte *buf, bool isThereFilter)
     && CheckDicSize(LzmaProps + 1);
 }
 
-class CDecoder Z7_final
+class CDecoder
 {
   CMyComPtr<ISequentialOutStream> _bcjStream;
   CFilterCoder *_filterCoder;
+  CMyComPtr<ICompressCoder> _lzmaDecoder;
 public:
-  CMyComPtr2<ICompressCoder, NCompress::NLzma::CDecoder> _lzmaDecoder;
+  NCompress::NLzma::CDecoder *_lzmaDecoderSpec;
 
   ~CDecoder();
   HRESULT Create(bool filtered, ISequentialInStream *inStream);
 
   HRESULT Code(const CHeader &header, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
 
-  UInt64 GetInputProcessedSize() const { return _lzmaDecoder->GetInputProcessedSize(); }
+  UInt64 GetInputProcessedSize() const { return _lzmaDecoderSpec->GetInputProcessedSize(); }
 
-  void ReleaseInStream() { if (_lzmaDecoder) _lzmaDecoder->ReleaseInStream(); }
+  void ReleaseInStream() { if (_lzmaDecoder) _lzmaDecoderSpec->ReleaseInStream(); }
 
   HRESULT ReadInput(Byte *data, UInt32 size, UInt32 *processedSize)
-    { return _lzmaDecoder->ReadFromInputStream(data, size, processedSize); }
+    { return _lzmaDecoderSpec->ReadFromInputStream(data, size, processedSize); }
 };
 
 HRESULT CDecoder::Create(bool filteredMode, ISequentialInStream *inStream)
 {
-  _lzmaDecoder.Create_if_Empty();
-  _lzmaDecoder->FinishStream = true;
+  if (!_lzmaDecoder)
+  {
+    _lzmaDecoderSpec = new NCompress::NLzma::CDecoder;
+    _lzmaDecoderSpec->FinishStream = true;
+    _lzmaDecoder = _lzmaDecoderSpec;
+  }
 
   if (filteredMode)
   {
@@ -107,12 +112,12 @@ HRESULT CDecoder::Create(bool filteredMode, ISequentialInStream *inStream)
     {
       _filterCoder = new CFilterCoder(false);
       CMyComPtr<ICompressCoder> coder = _filterCoder;
-      _filterCoder->Filter = new NCompress::NBcj::CCoder2(z7_BranchConvSt_X86_Dec);
+      _filterCoder->Filter = new NCompress::NBcj::CCoder(false);
       _bcjStream = _filterCoder;
     }
   }
 
-  return _lzmaDecoder->SetInStream(inStream);
+  return _lzmaDecoderSpec->SetInStream(inStream);
 }
 
 CDecoder::~CDecoder()
@@ -126,19 +131,19 @@ HRESULT CDecoder::Code(const CHeader &header, ISequentialOutStream *outStream,
   if (header.FilterID > 1)
     return E_NOTIMPL;
 
-  RINOK(_lzmaDecoder->SetDecoderProperties2(header.LzmaProps, 5))
+  RINOK(_lzmaDecoderSpec->SetDecoderProperties2(header.LzmaProps, 5));
 
   bool filteredMode = (header.FilterID == 1);
 
   if (filteredMode)
   {
-    RINOK(_filterCoder->SetOutStream(outStream))
+    RINOK(_filterCoder->SetOutStream(outStream));
     outStream = _bcjStream;
-    RINOK(_filterCoder->SetOutStreamSize(NULL))
+    RINOK(_filterCoder->SetOutStreamSize(NULL));
   }
 
   const UInt64 *Size = header.HasSize() ? &header.Size : NULL;
-  HRESULT res = _lzmaDecoder->CodeResume(outStream, Size, progress);
+  HRESULT res = _lzmaDecoderSpec->CodeResume(outStream, Size, progress);
 
   if (filteredMode)
   {
@@ -152,50 +157,60 @@ HRESULT CDecoder::Code(const CHeader &header, ISequentialOutStream *outStream,
       res = res2;
   }
   
-  RINOK(res)
+  RINOK(res);
 
   if (header.HasSize())
-    if (_lzmaDecoder->GetOutputProcessedSize() != header.Size)
+    if (_lzmaDecoderSpec->GetOutputProcessedSize() != header.Size)
       return S_FALSE;
 
   return S_OK;
 }
 
 
-Z7_CLASS_IMP_CHandler_IInArchive_1(
-  IArchiveOpenSeq
-)
+class CHandler:
+  public IInArchive,
+  public IArchiveOpenSeq,
+  public CMyUnknownImp
+{
+  CHeader _header;
   bool _lzma86;
+  CMyComPtr<IInStream> _stream;
+  CMyComPtr<ISequentialInStream> _seqStream;
+  
   bool _isArc;
   bool _needSeekToStart;
   bool _dataAfterEnd;
   bool _needMoreInput;
-  bool _unsupported;
-  bool _dataError;
 
   bool _packSize_Defined;
   bool _unpackSize_Defined;
   bool _numStreams_Defined;
 
-  CHeader _header;
-  CMyComPtr<IInStream> _stream;
-  CMyComPtr<ISequentialInStream> _seqStream;
-  
+  bool _unsupported;
+  bool _dataError;
+
   UInt64 _packSize;
   UInt64 _unpackSize;
   UInt64 _numStreams;
 
   void GetMethod(NCOM::CPropVariant &prop);
 
-  unsigned GetHeaderSize() const { return 5 + 8 + (_lzma86 ? 1 : 0); }
 public:
+  MY_UNKNOWN_IMP2(IInArchive, IArchiveOpenSeq)
+
+  INTERFACE_IInArchive(;)
+  STDMETHOD(OpenSeq)(ISequentialInStream *stream);
+
   CHandler(bool lzma86) { _lzma86 = lzma86; }
+
+  unsigned GetHeaderSize() const { return 5 + 8 + (_lzma86 ? 1 : 0); }
+
 };
 
 IMP_IInArchive_Props
 IMP_IInArchive_ArcProps
 
-Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
   NCOM::CPropVariant prop;
   switch (propID)
@@ -207,7 +222,7 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
     case kpidErrorFlags:
     {
       UInt32 v = 0;
-      if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+      if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;;
       if (_needMoreInput) v |= kpv_ErrorFlags_UnexpectedEnd;
       if (_dataAfterEnd) v |= kpv_ErrorFlags_DataAfterEnd;
       if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
@@ -215,38 +230,41 @@ Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
       prop = v;
       break;
     }
-    default: break;
   }
   prop.Detach(value);
   return S_OK;
 }
 
-Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
 {
   *numItems = 1;
   return S_OK;
 }
 
 
-static char * DictSizeToString(UInt32 val, char *s)
+static void DictSizeToString(UInt32 val, char *s)
 {
-  for (unsigned i = 0; i < 32; i++)
+  for (unsigned i = 0; i <= 31; i++)
     if (((UInt32)1 << i) == val)
-      return ::ConvertUInt32ToString(i, s);
+    {
+      ::ConvertUInt32ToString(i, s);
+      return;
+    }
   char c = 'b';
        if ((val & ((1 << 20) - 1)) == 0) { val >>= 20; c = 'm'; }
   else if ((val & ((1 << 10) - 1)) == 0) { val >>= 10; c = 'k'; }
-  s = ::ConvertUInt32ToString(val, s);
+  ::ConvertUInt32ToString(val, s);
+  s += MyStringLen(s);
   *s++ = c;
   *s = 0;
-  return s;
 }
 
 static char *AddProp32(char *s, const char *name, UInt32 v)
 {
   *s++ = ':';
   s = MyStpCpy(s, name);
-  return ::ConvertUInt32ToString(v, s);
+  ::ConvertUInt32ToString(v, s);
+  return s + MyStringLen(s);
 }
 
 void CHandler::GetMethod(NCOM::CPropVariant &prop)
@@ -259,7 +277,8 @@ void CHandler::GetMethod(NCOM::CPropVariant &prop)
   if (_header.FilterID != 0)
     s = MyStpCpy(s, "BCJ ");
   s = MyStpCpy(s, "LZMA:");
-  s = DictSizeToString(_header.GetDicSize(), s);
+  DictSizeToString(_header.GetDicSize(), s);
+  s += strlen(s);
   
   UInt32 d = _header.GetProp();
   // if (d != 0x5D)
@@ -276,7 +295,7 @@ void CHandler::GetMethod(NCOM::CPropVariant &prop)
 }
 
 
-Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value)
 {
   NCOM::CPropVariant prop;
   switch (propID)
@@ -284,7 +303,6 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIAN
     case kpidSize: if (_stream && _header.HasSize()) prop = _header.Size; break;
     case kpidPackSize: if (_packSize_Defined) prop = _packSize; break;
     case kpidMethod: GetMethod(prop); break;
-    default: break;
   }
   prop.Detach(value);
   return S_OK;
@@ -297,10 +315,10 @@ API_FUNC_static_IsArc IsArc_Lzma(const Byte *p, size_t size)
     return k_IsArc_Res_NEED_MORE;
   if (p[0] >= 5 * 5 * 9)
     return k_IsArc_Res_NO;
-  const UInt64 unpackSize = GetUi64(p + 1 + 4);
+  UInt64 unpackSize = GetUi64(p + 1 + 4);
   if (unpackSize != (UInt64)(Int64)-1)
   {
-    if (unpackSize >= ((UInt64)1 << 56))
+    if (size >= ((UInt64)1 << 56))
       return k_IsArc_Res_NO;
   }
   if (unpackSize != 0)
@@ -335,7 +353,7 @@ API_FUNC_static_IsArc IsArc_Lzma86(const Byte *p, size_t size)
 
 
 
-Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *))
+STDMETHODIMP CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCallback *)
 {
   Close();
   
@@ -343,7 +361,7 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCal
   const UInt32 kBufSize = 1 << 7;
   Byte buf[kBufSize];
   size_t processedSize = kBufSize;
-  RINOK(ReadStream(inStream, buf, &processedSize))
+  RINOK(ReadStream(inStream, buf, &processedSize));
   if (processedSize < headerSize + 2)
     return S_FALSE;
   if (!_header.Parse(buf, _lzma86))
@@ -352,9 +370,9 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCal
   if (start[0] != 0 /* || (start[1] & 0x80) != 0 */ ) // empty stream with EOS is not 0x80
     return S_FALSE;
 
-  RINOK(InStream_GetSize_SeekToEnd(inStream, _packSize))
+  RINOK(inStream->Seek(0, STREAM_SEEK_END, &_packSize));
 
-  SizeT srcLen = (SizeT)processedSize - headerSize;
+  SizeT srcLen = processedSize - headerSize;
 
   if (srcLen > 10
       && _header.Size == 0
@@ -363,6 +381,7 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCal
       )
     return S_FALSE;
 
+  CDecoder state;
   const UInt32 outLimit = 1 << 11;
   Byte outBuf[outLimit];
 
@@ -387,7 +406,7 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *inStream, const UInt64 *, IArchiveOpenCal
   return S_OK;
 }
 
-Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
+STDMETHODIMP CHandler::OpenSeq(ISequentialInStream *stream)
 {
   Close();
   _isArc = true;
@@ -395,38 +414,41 @@ Z7_COM7F_IMF(CHandler::OpenSeq(ISequentialInStream *stream))
   return S_OK;
 }
 
-Z7_COM7F_IMF(CHandler::Close())
+STDMETHODIMP CHandler::Close()
 {
   _isArc = false;
-  _needSeekToStart = false;
+  _packSize_Defined = false;
+  _unpackSize_Defined = false;
+  _numStreams_Defined = false;
+
   _dataAfterEnd = false;
   _needMoreInput = false;
   _unsupported = false;
   _dataError = false;
 
-  _packSize_Defined = false;
-  _unpackSize_Defined = false;
-  _numStreams_Defined = false;
-
   _packSize = 0;
 
+  _needSeekToStart = false;
+
   _stream.Release();
   _seqStream.Release();
    return S_OK;
 }
 
-Z7_CLASS_IMP_COM_1(
-  CCompressProgressInfoImp,
-  ICompressProgressInfo
-)
+class CCompressProgressInfoImp:
+  public ICompressProgressInfo,
+  public CMyUnknownImp
+{
   CMyComPtr<IArchiveOpenCallback> Callback;
 public:
   UInt64 Offset;
-
+ 
+  MY_UNKNOWN_IMP1(ICompressProgressInfo)
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
   void Init(IArchiveOpenCallback *callback) { Callback = callback; }
 };
 
-Z7_COM7F_IMF(CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */))
+STDMETHODIMP CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
 {
   if (Callback)
   {
@@ -437,8 +459,8 @@ Z7_COM7F_IMF(CCompressProgressInfoImp::SetRatioInfo(const UInt64 *inSize, const
   return S_OK;
 }
 
-Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
-    Int32 testMode, IArchiveExtractCallback *extractCallback))
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback)
 {
   COM_TRY_BEGIN
 
@@ -448,39 +470,41 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     return E_INVALIDARG;
 
   if (_packSize_Defined)
-    RINOK(extractCallback->SetTotal(_packSize))
+    extractCallback->SetTotal(_packSize);
     
-  Int32 opResult;
- {
+  
   CMyComPtr<ISequentialOutStream> realOutStream;
-  const Int32 askMode = testMode ?
+  Int32 askMode = testMode ?
       NExtract::NAskMode::kTest :
       NExtract::NAskMode::kExtract;
-  RINOK(extractCallback->GetStream(0, &realOutStream, askMode))
+  RINOK(extractCallback->GetStream(0, &realOutStream, askMode));
   if (!testMode && !realOutStream)
     return S_OK;
   
-  RINOK(extractCallback->PrepareOperation(askMode))
+  extractCallback->PrepareOperation(askMode);
 
-  CMyComPtr2_Create<ISequentialOutStream, CDummyOutStream> outStream;
-  outStream->SetStream(realOutStream);
-  outStream->Init();
+  CDummyOutStream *outStreamSpec = new CDummyOutStream;
+  CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
+  outStreamSpec->SetStream(realOutStream);
+  outStreamSpec->Init();
   realOutStream.Release();
 
-  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
   lps->Init(extractCallback, true);
 
   if (_needSeekToStart)
   {
     if (!_stream)
       return E_FAIL;
-    RINOK(InStream_SeekToBegin(_stream))
+    RINOK(_stream->Seek(0, STREAM_SEEK_SET, NULL));
   }
   else
     _needSeekToStart = true;
 
   CDecoder decoder;
-  RINOK(decoder.Create(_lzma86, _seqStream))
+  HRESULT result = decoder.Create(_lzma86, _seqStream);
+  RINOK(result);
  
   bool firstItem = true;
 
@@ -490,19 +514,17 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
   bool dataAfterEnd = false;
   
-  HRESULT hres = S_OK;
-
   for (;;)
   {
     lps->InSize = packSize;
     lps->OutSize = unpackSize;
-    RINOK(lps->SetCur())
+    RINOK(lps->SetCur());
 
     const UInt32 kBufSize = 1 + 5 + 8;
     Byte buf[kBufSize];
     const UInt32 headerSize = GetHeaderSize();
     UInt32 processed;
-    RINOK(decoder.ReadInput(buf, headerSize, &processed))
+    RINOK(decoder.ReadInput(buf, headerSize, &processed));
     if (processed != headerSize)
     {
       if (processed != 0)
@@ -519,32 +541,32 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     numStreams++;
     firstItem = false;
 
-    hres = decoder.Code(st, outStream, lps);
+    result = decoder.Code(st, outStream, progress);
 
     packSize = decoder.GetInputProcessedSize();
-    unpackSize = outStream->GetSize();
+    unpackSize = outStreamSpec->GetSize();
     
-    if (hres == E_NOTIMPL)
+    if (result == E_NOTIMPL)
     {
       _unsupported = true;
-      hres = S_FALSE;
+      result = S_FALSE;
       break;
     }
-    if (hres == S_FALSE)
+    if (result == S_FALSE)
       break;
-    RINOK(hres)
+    RINOK(result);
   }
 
   if (firstItem)
   {
     _isArc = false;
-    hres = S_FALSE;
+    result = S_FALSE;
   }
-  else if (hres == S_OK || hres == S_FALSE)
+  else if (result == S_OK || result == S_FALSE)
   {
     if (dataAfterEnd)
       _dataAfterEnd = true;
-    else if (decoder._lzmaDecoder->NeedsMoreInput())
+    else if (decoder._lzmaDecoderSpec->NeedsMoreInput())
       _needMoreInput = true;
 
     _packSize = packSize;
@@ -556,7 +578,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     _numStreams_Defined = true;
   }
   
-  opResult = NExtract::NOperationResult::kOK;
+  Int32 opResult = NExtract::NOperationResult::kOK;
 
   if (!_isArc)
     opResult = NExtract::NOperationResult::kIsNotArc;
@@ -566,15 +588,14 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     opResult = NExtract::NOperationResult::kUnsupportedMethod;
   else if (_dataAfterEnd)
     opResult = NExtract::NOperationResult::kDataAfterEnd;
-  else if (hres == S_FALSE)
+  else if (result == S_FALSE)
     opResult = NExtract::NOperationResult::kDataError;
-  else if (hres == S_OK)
+  else if (result == S_OK)
     opResult = NExtract::NOperationResult::kOK;
   else
-    return hres;
+    return result;
 
-  // outStream.Release();
- }
+  outStream.Release();
   return extractCallback->SetOperationResult(opResult);
 
   COM_TRY_END
@@ -586,7 +607,7 @@ namespace NLzmaAr {
 
 REGISTER_ARC_I_CLS_NO_SIG(
   CHandler(false),
-  "lzma", "lzma", NULL, 0xA,
+  "lzma", "lzma", 0, 0xA,
   0,
   NArcInfoFlags::kStartOpen |
   NArcInfoFlags::kKeepName,
@@ -598,7 +619,7 @@ namespace NLzma86Ar {
 
 REGISTER_ARC_I_CLS_NO_SIG(
   CHandler(true),
-  "lzma86", "lzma86", NULL, 0xB,
+  "lzma86", "lzma86", 0, 0xB,
   0,
   NArcInfoFlags::kKeepName,
   IsArc_Lzma86)