react-native-update 10.34.3 → 10.34.4

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

@@ -1,18 +1,18 @@
 // FilterCoder.h
 
-#ifndef ZIP7_INC_FILTER_CODER_H
-#define ZIP7_INC_FILTER_CODER_H
+#ifndef __FILTER_CODER_H
+#define __FILTER_CODER_H
 
 #include "../../../C/Alloc.h"
 
 #include "../../Common/MyCom.h"
 #include "../ICoder.h"
 
-#ifndef Z7_NO_CRYPTO
+#ifndef _NO_CRYPTO
 #include "../IPassword.h"
 #endif
 
-#define Z7_COM_QI_ENTRY_AG(i, sub0, sub) else if (iid == IID_ ## i) \
+#define MY_QUERYINTERFACE_ENTRY_AG(i, sub0, sub) else if (iid == IID_ ## i) \
   { if (!sub) RINOK(sub0->QueryInterface(IID_ ## i, (void **)&sub)) \
     *outObject = (void *)(i *)this; }
 
@@ -26,8 +26,7 @@ struct CAlignedMidBuffer
   void AllocAligned(size_t size);
 };
 
-
-class CFilterCoder Z7_final :
+class CFilterCoder:
   public ICompressCoder,
   
   public ICompressSetOutStreamSize,
@@ -42,15 +41,14 @@ class CFilterCoder Z7_final :
   
   public ICompressSetBufSize,
 
-  #ifndef Z7_NO_CRYPTO
+  #ifndef _NO_CRYPTO
   public ICryptoSetPassword,
   public ICryptoProperties,
   #endif
   
-  #ifndef Z7_EXTRACT_ONLY
+  #ifndef EXTRACT_ONLY
   public ICompressSetCoderProperties,
   public ICompressWriteCoderProperties,
-  public ICompressSetCoderPropertiesOpt,
   // public ICryptoResetSalt,
   public ICryptoResetInitVector,
   #endif
@@ -64,7 +62,7 @@ class CFilterCoder Z7_final :
   UInt32 _outBufSize;
 
   bool _encodeMode;
-  bool _outSize_Defined;
+  bool _outSizeIsDefined;
   UInt64 _outSize;
   UInt64 _nowPos64;
 
@@ -80,7 +78,7 @@ class CFilterCoder Z7_final :
     _convPos = 0;
     _convSize = 0;
 
-    _outSize_Defined = false;
+    _outSizeIsDefined = false;
     _outSize = 0;
     _nowPos64 = 0;
   }
@@ -89,111 +87,117 @@ class CFilterCoder Z7_final :
   HRESULT Init_and_Alloc();
   HRESULT Flush2();
 
-  #ifndef Z7_NO_CRYPTO
-  CMyComPtr<ICryptoSetPassword> _setPassword;
-  CMyComPtr<ICryptoProperties> _cryptoProperties;
+  #ifndef _NO_CRYPTO
+  CMyComPtr<ICryptoSetPassword> _SetPassword;
+  CMyComPtr<ICryptoProperties> _CryptoProperties;
   #endif
 
-  #ifndef Z7_EXTRACT_ONLY
-  CMyComPtr<ICompressSetCoderProperties> _setCoderProperties;
-  CMyComPtr<ICompressWriteCoderProperties> _writeCoderProperties;
-  CMyComPtr<ICompressSetCoderPropertiesOpt> _setCoderPropertiesOpt;
-  // CMyComPtr<ICryptoResetSalt> _cryptoResetSalt;
-  CMyComPtr<ICryptoResetInitVector> _cryptoResetInitVector;
+  #ifndef EXTRACT_ONLY
+  CMyComPtr<ICompressSetCoderProperties> _SetCoderProperties;
+  CMyComPtr<ICompressWriteCoderProperties> _WriteCoderProperties;
+  // CMyComPtr<ICryptoResetSalt> _CryptoResetSalt;
+  CMyComPtr<ICryptoResetInitVector> _CryptoResetInitVector;
   #endif
 
-  CMyComPtr<ICompressSetDecoderProperties2> _setDecoderProperties2;
+  CMyComPtr<ICompressSetDecoderProperties2> _SetDecoderProperties2;
 
 public:
   CMyComPtr<ICompressFilter> Filter;
 
   CFilterCoder(bool encodeMode);
+  ~CFilterCoder();
 
-  struct C_InStream_Releaser
+  class C_InStream_Releaser
   {
+  public:
     CFilterCoder *FilterCoder;
     C_InStream_Releaser(): FilterCoder(NULL) {}
     ~C_InStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseInStream(); }
   };
   
-  struct C_OutStream_Releaser
+  class C_OutStream_Releaser
   {
+  public:
     CFilterCoder *FilterCoder;
     C_OutStream_Releaser(): FilterCoder(NULL) {}
     ~C_OutStream_Releaser() { if (FilterCoder) FilterCoder->ReleaseOutStream(); }
   };
 
-  struct C_Filter_Releaser
+  class C_Filter_Releaser
   {
+  public:
     CFilterCoder *FilterCoder;
     C_Filter_Releaser(): FilterCoder(NULL) {}
     ~C_Filter_Releaser() { if (FilterCoder) FilterCoder->Filter.Release(); }
   };
   
-private:
-  Z7_COM_QI_BEGIN2(ICompressCoder)
 
-    Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
-    Z7_COM_QI_ENTRY(ICompressInitEncoder)
+  MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
+
+    MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
+    MY_QUERYINTERFACE_ENTRY(ICompressInitEncoder)
     
-    Z7_COM_QI_ENTRY(ICompressSetInStream)
-    Z7_COM_QI_ENTRY(ISequentialInStream)
+    MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
+    MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
     
-    Z7_COM_QI_ENTRY(ICompressSetOutStream)
-    Z7_COM_QI_ENTRY(ISequentialOutStream)
-    Z7_COM_QI_ENTRY(IOutStreamFinish)
+    MY_QUERYINTERFACE_ENTRY(ICompressSetOutStream)
+    MY_QUERYINTERFACE_ENTRY(ISequentialOutStream)
+    MY_QUERYINTERFACE_ENTRY(IOutStreamFinish)
     
-    Z7_COM_QI_ENTRY(ICompressSetBufSize)
+    MY_QUERYINTERFACE_ENTRY(ICompressSetBufSize)
 
-    #ifndef Z7_NO_CRYPTO
-    Z7_COM_QI_ENTRY_AG(ICryptoSetPassword, Filter, _setPassword)
-    Z7_COM_QI_ENTRY_AG(ICryptoProperties, Filter, _cryptoProperties)
+    #ifndef _NO_CRYPTO
+    MY_QUERYINTERFACE_ENTRY_AG(ICryptoSetPassword, Filter, _SetPassword)
+    MY_QUERYINTERFACE_ENTRY_AG(ICryptoProperties, Filter, _CryptoProperties)
     #endif
 
-    #ifndef Z7_EXTRACT_ONLY
-    Z7_COM_QI_ENTRY_AG(ICompressSetCoderProperties, Filter, _setCoderProperties)
-    Z7_COM_QI_ENTRY_AG(ICompressWriteCoderProperties, Filter, _writeCoderProperties)
-    Z7_COM_QI_ENTRY_AG(ICompressSetCoderPropertiesOpt, Filter, _setCoderPropertiesOpt)
-    // Z7_COM_QI_ENTRY_AG(ICryptoResetSalt, Filter, _cryptoResetSalt)
-    Z7_COM_QI_ENTRY_AG(ICryptoResetInitVector, Filter, _cryptoResetInitVector)
+    #ifndef EXTRACT_ONLY
+    MY_QUERYINTERFACE_ENTRY_AG(ICompressSetCoderProperties, Filter, _SetCoderProperties)
+    MY_QUERYINTERFACE_ENTRY_AG(ICompressWriteCoderProperties, Filter, _WriteCoderProperties)
+    // MY_QUERYINTERFACE_ENTRY_AG(ICryptoResetSalt, Filter, _CryptoResetSalt)
+    MY_QUERYINTERFACE_ENTRY_AG(ICryptoResetInitVector, Filter, _CryptoResetInitVector)
     #endif
 
-    Z7_COM_QI_ENTRY_AG(ICompressSetDecoderProperties2, Filter, _setDecoderProperties2)
-  Z7_COM_QI_END
-  Z7_COM_ADDREF_RELEASE
+    MY_QUERYINTERFACE_ENTRY_AG(ICompressSetDecoderProperties2, Filter, _SetDecoderProperties2)
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
   
-public:
-  Z7_IFACE_COM7_IMP(ICompressCoder)
-  Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
-  Z7_IFACE_COM7_IMP(ICompressInitEncoder)
-  Z7_IFACE_COM7_IMP(ICompressSetInStream)
-private:
-  Z7_IFACE_COM7_IMP(ISequentialInStream)
-public:
-  Z7_IFACE_COM7_IMP(ICompressSetOutStream)
-private:
-  Z7_IFACE_COM7_IMP(ISequentialOutStream)
-public:
-  Z7_IFACE_COM7_IMP(IOutStreamFinish)
-private:
   
-  Z7_IFACE_COM7_IMP(ICompressSetBufSize)
+  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
+  STDMETHOD(InitEncoder)();
 
-  #ifndef Z7_NO_CRYPTO
-  Z7_IFACE_COM7_IMP(ICryptoSetPassword)
-  Z7_IFACE_COM7_IMP(ICryptoProperties)
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+
+  STDMETHOD(SetOutStream)(ISequentialOutStream *outStream);
+  STDMETHOD(ReleaseOutStream)();
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(OutStreamFinish)();
+  
+  STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
+  STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
+
+  #ifndef _NO_CRYPTO
+  STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);
+
+  STDMETHOD(SetKey)(const Byte *data, UInt32 size);
+  STDMETHOD(SetInitVector)(const Byte *data, UInt32 size);
   #endif
   
-  #ifndef Z7_EXTRACT_ONLY
-  Z7_IFACE_COM7_IMP(ICompressSetCoderProperties)
-  Z7_IFACE_COM7_IMP(ICompressWriteCoderProperties)
-  Z7_IFACE_COM7_IMP(ICompressSetCoderPropertiesOpt)
-  // Z7_IFACE_COM7_IMP(ICryptoResetSalt)
-  Z7_IFACE_COM7_IMP(ICryptoResetInitVector)
+  #ifndef EXTRACT_ONLY
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs,
+      const PROPVARIANT *properties, UInt32 numProperties);
+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
+  // STDMETHOD(ResetSalt)();
+  STDMETHOD(ResetInitVector)();
   #endif
   
-public:
-  Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
+
   
   HRESULT Init_NoSubFilterInit();
 };

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

@@ -7,10 +7,10 @@
 #include "InBuffer.h"
 
 CInBufferBase::CInBufferBase() throw():
-  _buf(NULL),
-  _bufLim(NULL),
-  _bufBase(NULL),
-  _stream(NULL),
+  _buf(0),
+  _bufLim(0),
+  _bufBase(0),
+  _stream(0),
   _processedSize(0),
   _bufSize(0),
   _wasFinished(false),
@@ -22,18 +22,18 @@ bool CInBuffer::Create(size_t bufSize) throw()
   const unsigned kMinBlockSize = 1;
   if (bufSize < kMinBlockSize)
     bufSize = kMinBlockSize;
-  if (_bufBase != NULL && _bufSize == bufSize)
+  if (_bufBase != 0 && _bufSize == bufSize)
     return true;
   Free();
   _bufSize = bufSize;
   _bufBase = (Byte *)::MidAlloc(bufSize);
-  return (_bufBase != NULL);
+  return (_bufBase != 0);
 }
 
 void CInBuffer::Free() throw()
 {
   ::MidFree(_bufBase);
-  _bufBase = NULL;
+  _bufBase = 0;
 }
 
 void CInBufferBase::Init() throw()
@@ -42,7 +42,7 @@ void CInBufferBase::Init() throw()
   _buf = _bufBase;
   _bufLim = _buf;
   _wasFinished = false;
-  #ifdef Z7_NO_EXCEPTIONS
+  #ifdef _NO_EXCEPTIONS
   ErrorCode = S_OK;
   #endif
   NumExtraBytes = 0;
@@ -50,19 +50,19 @@ void CInBufferBase::Init() throw()
 
 bool CInBufferBase::ReadBlock()
 {
-  #ifdef Z7_NO_EXCEPTIONS
+  #ifdef _NO_EXCEPTIONS
   if (ErrorCode != S_OK)
     return false;
   #endif
   if (_wasFinished)
     return false;
-  _processedSize += (size_t)(_buf - _bufBase);
+  _processedSize += (_buf - _bufBase);
   _buf = _bufBase;
   _bufLim = _bufBase;
   UInt32 processed;
   // FIX_ME: we can improve it to support (_bufSize >= (1 << 32))
-  const HRESULT result = _stream->Read(_bufBase, (UInt32)_bufSize, &processed);
-  #ifdef Z7_NO_EXCEPTIONS
+  HRESULT result = _stream->Read(_bufBase, (UInt32)_bufSize, &processed);
+  #ifdef _NO_EXCEPTIONS
   ErrorCode = result;
   #else
   if (result != S_OK)
@@ -77,8 +77,7 @@ bool CInBufferBase::ReadByte_FromNewBlock(Byte &b)
 {
   if (!ReadBlock())
   {
-    // 22.00: we don't increment (NumExtraBytes) here
-    // NumExtraBytes++;
+    NumExtraBytes++;
     b = 0xFF;
     return false;
   }
@@ -96,30 +95,12 @@ Byte CInBufferBase::ReadByte_FromNewBlock()
   return *_buf++;
 }
 
-size_t CInBufferBase::ReadBytesPart(Byte *buf, size_t size)
-{
-  if (size == 0)
-    return 0;
-  size_t rem = (size_t)(_bufLim - _buf);
-  if (rem == 0)
-  {
-    if (!ReadBlock())
-      return 0;
-    rem = (size_t)(_bufLim - _buf);
-  }
-  if (size > rem)
-      size = rem;
-  memcpy(buf, _buf, size);
-  _buf += size;
-  return size;
-}
-
 size_t CInBufferBase::ReadBytes(Byte *buf, size_t size)
 {
   size_t num = 0;
   for (;;)
   {
-    const size_t rem = (size_t)(_bufLim - _buf);
+    const size_t rem = _bufLim - _buf;
     if (size <= rem)
     {
       if (size != 0)
@@ -167,7 +148,7 @@ size_t CInBufferBase::Skip(size_t size)
   size_t processed = 0;
   for (;;)
   {
-    const size_t rem = (size_t)(_bufLim - _buf);
+    size_t rem = (_bufLim - _buf);
     if (rem >= size)
     {
       _buf += size;

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

@@ -1,12 +1,12 @@
 // InBuffer.h
 
-#ifndef ZIP7_INC_IN_BUFFER_H
-#define ZIP7_INC_IN_BUFFER_H
+#ifndef __IN_BUFFER_H
+#define __IN_BUFFER_H
 
 #include "../../Common/MyException.h"
 #include "../IStream.h"
 
-#ifndef Z7_NO_EXCEPTIONS
+#ifndef _NO_EXCEPTIONS
 struct CInBufferException: public CSystemException
 {
   CInBufferException(HRESULT errorCode): CSystemException(errorCode) {}
@@ -31,27 +31,18 @@ protected:
   Byte ReadByte_FromNewBlock();
 
 public:
-  #ifdef Z7_NO_EXCEPTIONS
+  #ifdef _NO_EXCEPTIONS
   HRESULT ErrorCode;
   #endif
   UInt32 NumExtraBytes;
 
   CInBufferBase() throw();
 
-  // the size of portion of data in real stream that was already read from this object
-  // it doesn't include unused data in buffer
-  // it doesn't include virtual Extra bytes after the end of real stream data
-  UInt64 GetStreamSize() const { return _processedSize + (size_t)(_buf - _bufBase); }
-  
-  // the size of virtual data that was read from this object
-  // it doesn't include unused data in buffers
-  // it includes any virtual Extra bytes after the end of real data
-  UInt64 GetProcessedSize() const { return _processedSize + NumExtraBytes + (size_t)(_buf - _bufBase); }
-
+  UInt64 GetStreamSize() const { return _processedSize + (_buf - _bufBase); }
+  UInt64 GetProcessedSize() const { return _processedSize + NumExtraBytes + (_buf - _bufBase); }
   bool WasFinished() const { return _wasFinished; }
 
   void SetStream(ISequentialInStream *stream) { _stream = stream; }
-  void ClearStreamPtr() { _stream = NULL; }
   
   void SetBuf(Byte *buf, size_t bufSize, size_t end, size_t pos)
   {
@@ -61,7 +52,7 @@ public:
     _buf = buf + pos;
     _bufLim = buf + end;
     _wasFinished = false;
-    #ifdef Z7_NO_EXCEPTIONS
+    #ifdef _NO_EXCEPTIONS
     ErrorCode = S_OK;
     #endif
     NumExtraBytes = 0;
@@ -69,7 +60,7 @@ public:
 
   void Init() throw();
   
-  Z7_FORCE_INLINE
+  MY_FORCE_INLINE
   bool ReadByte(Byte &b)
   {
     if (_buf >= _bufLim)
@@ -77,17 +68,8 @@ public:
     b = *_buf++;
     return true;
   }
-
-  Z7_FORCE_INLINE
-  bool ReadByte_FromBuf(Byte &b)
-  {
-    if (_buf >= _bufLim)
-      return false;
-    b = *_buf++;
-    return true;
-  }
   
-  Z7_FORCE_INLINE
+  MY_FORCE_INLINE
   Byte ReadByte()
   {
     if (_buf >= _bufLim)
@@ -95,18 +77,7 @@ public:
     return *_buf++;
   }
   
-  size_t ReadBytesPart(Byte *buf, size_t size);
   size_t ReadBytes(Byte *buf, size_t size);
-  const Byte *Lookahead(size_t &rem)
-  {
-    rem = (size_t)(_bufLim - _buf);
-    if (!rem)
-    {
-      ReadBlock();
-      rem = (size_t)(_bufLim - _buf);
-    }
-    return _buf;
-  }
   size_t Skip(size_t size);
 };