react-native-update 10.34.3 → 10.34.4

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

@@ -6,7 +6,7 @@
 
 #include "LimitedStreams.h"
 
-Z7_COM7F_IMF(CLimitedSequentialInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CLimitedSequentialInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 realProcessedSize = 0;
   {
@@ -27,7 +27,7 @@ Z7_COM7F_IMF(CLimitedSequentialInStream::Read(void *data, UInt32 size, UInt32 *p
   return result;
 }
 
-Z7_COM7F_IMF(CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -46,7 +46,7 @@ Z7_COM7F_IMF(CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSi
   if (newPos != _physPos)
   {
     _physPos = newPos;
-    RINOK(SeekToPhys())
+    RINOK(SeekToPhys());
   }
   HRESULT res = _stream->Read(data, size, &size);
   if (processedSize)
@@ -56,7 +56,7 @@ Z7_COM7F_IMF(CLimitedInStream::Read(void *data, UInt32 size, UInt32 *processedSi
   return res;
 }
 
-Z7_COM7F_IMF(CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -67,7 +67,7 @@ Z7_COM7F_IMF(CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *new
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _virtPos = (UInt64)offset;
+  _virtPos = offset;
   if (newPosition)
     *newPosition = _virtPos;
   return S_OK;
@@ -75,17 +75,17 @@ Z7_COM7F_IMF(CLimitedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *new
 
 HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream)
 {
-  *resStream = NULL;
+  *resStream = 0;
   CLimitedInStream *streamSpec = new CLimitedInStream;
   CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
   streamSpec->SetStream(inStream);
-  RINOK(streamSpec->InitAndSeek(pos, size))
+  RINOK(streamSpec->InitAndSeek(pos, size));
   streamSpec->SeekToStart();
   *resStream = streamTemp.Detach();
   return S_OK;
 }
 
-Z7_COM7F_IMF(CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -110,12 +110,12 @@ Z7_COM7F_IMF(CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSi
     if (newPos != _physPos)
     {
       _physPos = newPos;
-      RINOK(SeekToPhys())
+      RINOK(SeekToPhys());
     }
 
     _curRem = blockSize - offsetInBlock;
     
-    for (unsigned i = 1; i < 64 && (virtBlock + i) < (UInt32)Vector.Size() && phyBlock + i == Vector[virtBlock + i]; i++)
+    for (int i = 1; i < 64 && (virtBlock + i) < (UInt32)Vector.Size() && phyBlock + i == Vector[virtBlock + i]; i++)
       _curRem += (UInt32)1 << BlockSizeLog;
   }
   
@@ -130,7 +130,7 @@ Z7_COM7F_IMF(CClusterInStream::Read(void *data, UInt32 size, UInt32 *processedSi
   return res;
 }
  
-Z7_COM7F_IMF(CClusterInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CClusterInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -143,82 +143,56 @@ Z7_COM7F_IMF(CClusterInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *new
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
   if (_virtPos != (UInt64)offset)
     _curRem = 0;
-  _virtPos = (UInt64)offset;
+  _virtPos = offset;
   if (newPosition)
-    *newPosition = (UInt64)offset;
+    *newPosition = offset;
   return S_OK;
 }
 
 
-Z7_COM7F_IMF(CExtentsStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CExtentsStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
-  const UInt64 virt = _virtPos;
-  if (virt >= Extents.Back().Virt)
+  if (_virtPos >= Extents.Back().Virt)
     return S_OK;
   if (size == 0)
     return S_OK;
   
-  unsigned left = _prevExtentIndex;
-  if (virt <  Extents[left].Virt ||
-      virt >= Extents[left + 1].Virt)
+  unsigned left = 0, right = Extents.Size() - 1;
+  for (;;)
   {
-    left = 0;
-    unsigned right = Extents.Size() - 1;
-    for (;;)
-    {
-      const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-      if (mid == left)
-        break;
-      if (virt < Extents[mid].Virt)
-        right = mid;
-      else
-        left = mid;
-    }
-    _prevExtentIndex = left;
-  }
-  
-  {
-    const UInt64 rem = Extents[left + 1].Virt - virt;
-    if (size > rem)
-      size = (UInt32)rem;
+    unsigned mid = (left + right) / 2;
+    if (mid == left)
+      break;
+    if (_virtPos < Extents[mid].Virt)
+      right = mid;
+    else
+      left = mid;
   }
   
   const CSeekExtent &extent = Extents[left];
-  
-  if (extent.Is_ZeroFill())
+  UInt64 phyPos = extent.Phy + (_virtPos - extent.Virt);
+  if (_needStartSeek || _phyPos != phyPos)
   {
-    memset(data, 0, size);
-    _virtPos += size;
-    if (processedSize)
-      *processedSize = size;
-    return S_OK;
-  }
-
-  {
-    const UInt64 phy = extent.Phy + (virt - extent.Virt);
-    if (_phyPos != phy)
-    {
-      _phyPos = (UInt64)0 - 1;  // we don't trust seek_pos in case of error
-      RINOK(InStream_SeekSet(Stream, phy))
-      _phyPos = phy;
-    }
+    _needStartSeek = false;
+    _phyPos = phyPos;
+    RINOK(SeekToPhys());
   }
   
-  const HRESULT res = Stream->Read(data, size, &size);
+  UInt64 rem = Extents[left + 1].Virt - _virtPos;
+  if (size > rem)
+    size = (UInt32)rem;
+  
+  HRESULT res = Stream->Read(data, size, &size);
+  _phyPos += size;
   _virtPos += size;
-  if (res == S_OK)
-    _phyPos += size;
-  else
-    _phyPos = (UInt64)0 - 1;  // we don't trust seek_pos in case of error
   if (processedSize)
     *processedSize = size;
   return res;
 }
 
-
-Z7_COM7F_IMF(CExtentsStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CExtentsStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -229,14 +203,14 @@ Z7_COM7F_IMF(CExtentsStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPo
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _virtPos = (UInt64)offset;
+  _virtPos = offset;
   if (newPosition)
     *newPosition = _virtPos;
   return S_OK;
 }
 
 
-Z7_COM7F_IMF(CLimitedSequentialOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CLimitedSequentialOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   HRESULT result = S_OK;
   if (processedSize)
@@ -263,7 +237,7 @@ Z7_COM7F_IMF(CLimitedSequentialOutStream::Write(const void *data, UInt32 size, U
 }
 
 
-Z7_COM7F_IMF(CTailInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CTailInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 cur;
   HRESULT res = Stream->Read(data, size, &cur);
@@ -273,7 +247,7 @@ Z7_COM7F_IMF(CTailInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
   return res;
 }
   
-Z7_COM7F_IMF(CTailInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CTailInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -282,7 +256,7 @@ Z7_COM7F_IMF(CTailInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPos
     case STREAM_SEEK_END:
     {
       UInt64 pos = 0;
-      RINOK(Stream->Seek(offset, STREAM_SEEK_END, &pos))
+      RINOK(Stream->Seek(offset, STREAM_SEEK_END, &pos));
       if (pos < Offset)
         return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
       _virtPos = pos - Offset;
@@ -294,13 +268,13 @@ Z7_COM7F_IMF(CTailInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPos
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _virtPos = (UInt64)offset;
+  _virtPos = offset;
   if (newPosition)
     *newPosition = _virtPos;
-  return InStream_SeekSet(Stream, Offset + _virtPos);
+  return Stream->Seek(Offset + _virtPos, STREAM_SEEK_SET, NULL);
 }
 
-Z7_COM7F_IMF(CLimitedCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CLimitedCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -329,7 +303,7 @@ Z7_COM7F_IMF(CLimitedCachedInStream::Read(void *data, UInt32 size, UInt32 *proce
     if (newPos != _physPos)
     {
       _physPos = newPos;
-      RINOK(SeekToPhys())
+      RINOK(SeekToPhys());
     }
     res = _stream->Read(data, size, &size);
     _physPos += size;
@@ -340,7 +314,7 @@ Z7_COM7F_IMF(CLimitedCachedInStream::Read(void *data, UInt32 size, UInt32 *proce
   return res;
 }
 
-Z7_COM7F_IMF(CLimitedCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CLimitedCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -351,13 +325,13 @@ Z7_COM7F_IMF(CLimitedCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt6
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _virtPos = (UInt64)offset;
+  _virtPos = offset;
   if (newPosition)
     *newPosition = _virtPos;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CTailOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CTailOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 cur;
   HRESULT res = Stream->Write(data, size, &cur);
@@ -369,7 +343,7 @@ Z7_COM7F_IMF(CTailOutStream::Write(const void *data, UInt32 size, UInt32 *proces
   return res;
 }
   
-Z7_COM7F_IMF(CTailOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CTailOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -380,13 +354,13 @@ Z7_COM7F_IMF(CTailOutStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPo
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _virtPos = (UInt64)offset;
+  _virtPos = offset;
   if (newPosition)
     *newPosition = _virtPos;
-  return Stream->Seek((Int64)(Offset + _virtPos), STREAM_SEEK_SET, NULL);
+  return Stream->Seek(Offset + _virtPos, STREAM_SEEK_SET, NULL);
 }
 
-Z7_COM7F_IMF(CTailOutStream::SetSize(UInt64 newSize))
+STDMETHODIMP CTailOutStream::SetSize(UInt64 newSize)
 {
   _virtSize = newSize;
   return Stream->SetSize(Offset + newSize);

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

@@ -1,19 +1,17 @@
 // LimitedStreams.h
 
-#ifndef ZIP7_INC_LIMITED_STREAMS_H
-#define ZIP7_INC_LIMITED_STREAMS_H
+#ifndef __LIMITED_STREAMS_H
+#define __LIMITED_STREAMS_H
 
 #include "../../Common/MyBuffer.h"
 #include "../../Common/MyCom.h"
 #include "../../Common/MyVector.h"
 #include "../IStream.h"
 
-#include "StreamUtils.h"
-
-Z7_CLASS_IMP_COM_1(
-  CLimitedSequentialInStream
-  , ISequentialInStream
-)
+class CLimitedSequentialInStream:
+  public ISequentialInStream,
+  public CMyUnknownImp
+{
   CMyComPtr<ISequentialInStream> _stream;
   UInt64 _size;
   UInt64 _pos;
@@ -27,22 +25,26 @@ public:
     _pos = 0;
     _wasFinished = false;
   }
+ 
+  MY_UNKNOWN_IMP1(ISequentialInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
   UInt64 GetSize() const { return _pos; }
   UInt64 GetRem() const { return _size - _pos; }
   bool WasFinished() const { return _wasFinished; }
 };
 
-
-Z7_CLASS_IMP_IInStream(
-  CLimitedInStream
-)
+class CLimitedInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
   CMyComPtr<IInStream> _stream;
   UInt64 _virtPos;
   UInt64 _physPos;
   UInt64 _size;
   UInt64 _startOffset;
 
-  HRESULT SeekToPhys() { return InStream_SeekSet(_stream, _physPos); }
+  HRESULT SeekToPhys() { return _stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
 public:
   void SetStream(IInStream *stream) { _stream = stream; }
   HRESULT InitAndSeek(UInt64 startOffset, UInt64 size)
@@ -53,15 +55,21 @@ public:
     _size = size;
     return SeekToPhys();
   }
+ 
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+
   HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
 };
 
 HRESULT CreateLimitedInStream(IInStream *inStream, UInt64 pos, UInt64 size, ISequentialInStream **resStream);
 
-
-Z7_CLASS_IMP_IInStream(
-  CClusterInStream
-)
+class CClusterInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
   UInt64 _virtPos;
   UInt64 _physPos;
   UInt32 _curRem;
@@ -72,7 +80,7 @@ public:
   CRecordVector<UInt32> Vector;
   UInt64 StartOffset;
 
-  HRESULT SeekToPhys() { return InStream_SeekSet(Stream, _physPos); }
+  HRESULT SeekToPhys() { return Stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
 
   HRESULT InitAndSeek()
   {
@@ -86,52 +94,57 @@ public:
     }
     return S_OK;
   }
-};
 
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
 
-
-const UInt64 k_SeekExtent_Phy_Type_ZeroFill = (UInt64)(Int64)-1;
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+};
 
 struct CSeekExtent
 {
-  UInt64 Virt;
   UInt64 Phy;
-
-  void SetAs_ZeroFill() { Phy = k_SeekExtent_Phy_Type_ZeroFill; }
-  bool Is_ZeroFill() const { return Phy == k_SeekExtent_Phy_Type_ZeroFill; }
+  UInt64 Virt;
 };
 
-
-Z7_CLASS_IMP_IInStream(
-  CExtentsStream
-)
-  UInt64 _virtPos;
+class CExtentsStream:
+  public IInStream,
+  public CMyUnknownImp
+{
   UInt64 _phyPos;
-  unsigned _prevExtentIndex;
+  UInt64 _virtPos;
+  bool _needStartSeek;
+
+  HRESULT SeekToPhys() { return Stream->Seek(_phyPos, STREAM_SEEK_SET, NULL); }
+
 public:
   CMyComPtr<IInStream> Stream;
   CRecordVector<CSeekExtent> Extents;
 
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
   void ReleaseStream() { Stream.Release(); }
+
   void Init()
   {
     _virtPos = 0;
-    _phyPos = (UInt64)0 - 1; // we need Seek() for Stream
-    _prevExtentIndex = 0;
+    _phyPos = 0;
+    _needStartSeek = true;
   }
 };
 
-
-
-Z7_CLASS_IMP_COM_1(
-  CLimitedSequentialOutStream
-  , ISequentialOutStream
-)
+class CLimitedSequentialOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
   CMyComPtr<ISequentialOutStream> _stream;
   UInt64 _size;
   bool _overflow;
   bool _overflowIsAllowed;
 public:
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   void SetStream(ISequentialOutStream *stream) { _stream = stream; }
   void ReleaseStream() { _stream.Release(); }
   void Init(UInt64 size, bool overflowIsAllowed = false)
@@ -145,9 +158,10 @@ public:
 };
 
 
-Z7_CLASS_IMP_IInStream(
-  CTailInStream
-)
+class CTailInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
   UInt64 _virtPos;
 public:
   CMyComPtr<IInStream> Stream;
@@ -157,13 +171,19 @@ public:
   {
     _virtPos = 0;
   }
-  HRESULT SeekToStart() { return InStream_SeekSet(Stream, Offset); }
-};
+ 
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
 
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
 
-Z7_CLASS_IMP_IInStream(
-  CLimitedCachedInStream
-)
+  HRESULT SeekToStart() { return Stream->Seek(Offset, STREAM_SEEK_SET, NULL); }
+};
+
+class CLimitedCachedInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
   CMyComPtr<IInStream> _stream;
   UInt64 _virtPos;
   UInt64 _physPos;
@@ -174,7 +194,8 @@ Z7_CLASS_IMP_IInStream(
   size_t _cacheSize;
   size_t _cachePhyPos;
 
-  HRESULT SeekToPhys() { return InStream_SeekSet(_stream, _physPos); }
+
+  HRESULT SeekToPhys() { return _stream->Seek(_physPos, STREAM_SEEK_SET, NULL); }
 public:
   CByteBuffer Buffer;
 
@@ -195,27 +216,37 @@ public:
     return SeekToPhys();
   }
  
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+
   HRESULT SeekToStart() { return Seek(0, STREAM_SEEK_SET, NULL); }
 };
 
-
-class CTailOutStream Z7_final :
+class CTailOutStream:
   public IOutStream,
   public CMyUnknownImp
 {
-  Z7_IFACES_IMP_UNK_2(ISequentialOutStream, IOutStream)
-
   UInt64 _virtPos;
   UInt64 _virtSize;
 public:
   CMyComPtr<IOutStream> Stream;
   UInt64 Offset;
   
+  virtual ~CTailOutStream() {}
+
+  MY_UNKNOWN_IMP2(ISequentialOutStream, IOutStream)
+
   void Init()
   {
     _virtPos = 0;
     _virtSize = 0;
   }
+
+  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/LockedStream.h

@@ -1,6 +1,6 @@
 // LockedStream.h
 
-#ifndef ZIP7_INC_LOCKED_STREAM_H
-#define ZIP7_INC_LOCKED_STREAM_H
+#ifndef __LOCKED_STREAM_H
+#define __LOCKED_STREAM_H
 
 #endif

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

@@ -1,7 +1,7 @@
 // MethodId.h
 
-#ifndef ZIP7_INC_7Z_METHOD_ID_H
-#define ZIP7_INC_7Z_METHOD_ID_H
+#ifndef __7Z_METHOD_ID_H
+#define __7Z_METHOD_ID_H
 
 #include "../../Common/MyTypes.h"