react-native-update 10.34.3 → 10.34.4

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

@@ -1,13 +1,13 @@
 // RegisterArc.h
 
-#ifndef ZIP7_INC_REGISTER_ARC_H
-#define ZIP7_INC_REGISTER_ARC_H
+#ifndef __REGISTER_ARC_H
+#define __REGISTER_ARC_H
 
 #include "../Archive/IArchive.h"
 
 struct CArcInfo
 {
-  UInt32 Flags;
+  UInt16 Flags;
   Byte Id;
   Byte SignatureSize;
   UInt16 SignatureOffset;
@@ -17,8 +17,6 @@ struct CArcInfo
   const char *Ext;
   const char *AddExt;
   
-  UInt32 TimeFlags;
-
   Func_CreateInArchive CreateInArchive;
   Func_CreateOutArchive CreateOutArchive;
   Func_IsArc IsArc;
@@ -34,29 +32,29 @@ void RegisterArc(const CArcInfo *arcInfo) throw();
 
 #define IMP_CreateArcIn IMP_CreateArcIn_2(CHandler())
 
-#ifdef Z7_EXTRACT_ONLY
+#ifdef EXTRACT_ONLY
   #define IMP_CreateArcOut
   #define CreateArcOut NULL
 #else
   #define IMP_CreateArcOut static IOutArchive *CreateArcOut() { return new CHandler(); }
 #endif
 
-#define REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, tf, crIn, crOut, isArc) \
-  static const CArcInfo g_ArcInfo = { flags, id, sigSize, offs, sig, n, e, ae, tf, crIn, crOut, isArc } ; \
+#define REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
+  static const CArcInfo g_ArcInfo = { flags, id, sigSize, offs, sig, n, e, ae, crIn, crOut, isArc } ; \
 
-#define REGISTER_ARC_R(n, e, ae, id, sigSize, sig, offs, flags, tf, crIn, crOut, isArc) \
-  REGISTER_ARC_V      (n, e, ae, id, sigSize, sig, offs, flags, tf, crIn, crOut, isArc) \
+#define REGISTER_ARC_R(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
+  REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
   struct CRegisterArc { CRegisterArc() { RegisterArc(&g_ArcInfo); }}; \
   static CRegisterArc g_RegisterArc;
 
 
 #define REGISTER_ARC_I_CLS(cls, n, e, ae, id, sig, offs, flags, isArc) \
   IMP_CreateArcIn_2(cls) \
-  REGISTER_ARC_R(n, e, ae, id, Z7_ARRAY_SIZE(sig), sig, offs, flags, 0, CreateArc, NULL, isArc)
+  REGISTER_ARC_R(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, NULL, isArc)
 
 #define REGISTER_ARC_I_CLS_NO_SIG(cls, n, e, ae, id, offs, flags, isArc) \
   IMP_CreateArcIn_2(cls) \
-  REGISTER_ARC_R(n, e, ae, id, 0, NULL, offs, flags, 0, CreateArc, NULL, isArc)
+  REGISTER_ARC_R(n, e, ae, id, 0, NULL, offs, flags, CreateArc, NULL, isArc)
 
 #define REGISTER_ARC_I(n, e, ae, id, sig, offs, flags, isArc) \
   REGISTER_ARC_I_CLS(CHandler(), n, e, ae, id, sig, offs, flags, isArc)
@@ -65,15 +63,15 @@ void RegisterArc(const CArcInfo *arcInfo) throw();
   REGISTER_ARC_I_CLS_NO_SIG(CHandler(), n, e, ae, id, offs, flags, isArc)
 
 
-#define REGISTER_ARC_IO(n, e, ae, id, sig, offs, flags, tf, isArc) \
+#define REGISTER_ARC_IO(n, e, ae, id, sig, offs, flags, isArc) \
   IMP_CreateArcIn \
   IMP_CreateArcOut \
-  REGISTER_ARC_R(n, e, ae, id, Z7_ARRAY_SIZE(sig), sig, offs, flags, tf, CreateArc, CreateArcOut, isArc)
+  REGISTER_ARC_R(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, CreateArcOut, isArc)
 
-#define REGISTER_ARC_IO_DECREMENT_SIG(n, e, ae, id, sig, offs, flags, tf, isArc) \
+#define REGISTER_ARC_IO_DECREMENT_SIG(n, e, ae, id, sig, offs, flags, isArc) \
   IMP_CreateArcIn \
   IMP_CreateArcOut \
-  REGISTER_ARC_V(n, e, ae, id, Z7_ARRAY_SIZE(sig), sig, offs, flags, tf, CreateArc, CreateArcOut, isArc) \
+  REGISTER_ARC_V(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, CreateArcOut, isArc) \
   struct CRegisterArcDecSig { CRegisterArcDecSig() { sig[0]--; RegisterArc(&g_ArcInfo); }}; \
   static CRegisterArcDecSig g_RegisterArc;
 

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

@@ -1,7 +1,7 @@
 // RegisterCodec.h
 
-#ifndef ZIP7_INC_REGISTER_CODEC_H
-#define ZIP7_INC_REGISTER_CODEC_H
+#ifndef __REGISTER_CODEC_H
+#define __REGISTER_CODEC_H
 
 #include "../Common/MethodId.h"
 
@@ -26,29 +26,29 @@ void RegisterCodec(const CCodecInfo *codecInfo) throw();
 #define REGISTER_CODEC_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressCoder)
 
 #define REGISTER_CODEC_NAME(x) CRegisterCodec ## x
-#define REGISTER_CODEC_VAR(x) static const CCodecInfo g_CodecInfo_ ## x =
+#define REGISTER_CODEC_VAR static const CCodecInfo g_CodecInfo =
 
 #define REGISTER_CODEC(x) struct REGISTER_CODEC_NAME(x) { \
-    REGISTER_CODEC_NAME(x)() { RegisterCodec(&g_CodecInfo_ ## x); }}; \
-    static REGISTER_CODEC_NAME(x) g_RegisterCodec_ ## x;
+    REGISTER_CODEC_NAME(x)() { RegisterCodec(&g_CodecInfo); }}; \
+    static REGISTER_CODEC_NAME(x) g_RegisterCodec;
 
 
 #define REGISTER_CODECS_NAME(x) CRegisterCodecs ## x
 #define REGISTER_CODECS_VAR static const CCodecInfo g_CodecsInfo[] =
 
 #define REGISTER_CODECS(x) struct REGISTER_CODECS_NAME(x) { \
-    REGISTER_CODECS_NAME(x)() { for (unsigned i = 0; i < Z7_ARRAY_SIZE(g_CodecsInfo); i++) \
+    REGISTER_CODECS_NAME(x)() { for (unsigned i = 0; i < ARRAY_SIZE(g_CodecsInfo); i++) \
     RegisterCodec(&g_CodecsInfo[i]); }}; \
     static REGISTER_CODECS_NAME(x) g_RegisterCodecs;
 
 
 #define REGISTER_CODEC_2(x, crDec, crEnc, id, name) \
-    REGISTER_CODEC_VAR(x) \
+    REGISTER_CODEC_VAR \
     { crDec, crEnc, id, name, 1, false }; \
     REGISTER_CODEC(x)
 
 
-#ifdef Z7_EXTRACT_ONLY
+#ifdef EXTRACT_ONLY
   #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
     REGISTER_CODEC_CREATE(CreateDec, clsDec) \
     REGISTER_CODEC_2(x, CreateDec, NULL, id, name)
@@ -67,19 +67,19 @@ void RegisterCodec(const CCodecInfo *codecInfo) throw();
     { crDec, crEnc, id, name, 1, true }
 
 #define REGISTER_FILTER(x, crDec, crEnc, id, name) \
-    REGISTER_CODEC_VAR(x) \
+    REGISTER_CODEC_VAR \
     REGISTER_FILTER_ITEM(crDec, crEnc, id, name); \
     REGISTER_CODEC(x)
 
-#ifdef Z7_EXTRACT_ONLY
+#ifdef EXTRACT_ONLY
   #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
-    REGISTER_FILTER_CREATE(x ## _CreateDec, clsDec) \
-    REGISTER_FILTER(x, x ## _CreateDec, NULL, id, name)
+    REGISTER_FILTER_CREATE(CreateDec, clsDec) \
+    REGISTER_FILTER(x, CreateDec, NULL, id, name)
 #else
   #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
-    REGISTER_FILTER_CREATE(x ## _CreateDec, clsDec) \
-    REGISTER_FILTER_CREATE(x ## _CreateEnc, clsEnc) \
-    REGISTER_FILTER(x, x ## _CreateDec, x ## _CreateEnc, id, name)
+    REGISTER_FILTER_CREATE(CreateDec, clsDec) \
+    REGISTER_FILTER_CREATE(CreateEnc, clsEnc) \
+    REGISTER_FILTER(x, CreateDec, CreateEnc, id, name)
 #endif
 
 
@@ -97,7 +97,7 @@ void RegisterHasher(const CHasherInfo *hasher) throw();
 #define REGISTER_HASHER_NAME(x) CRegHasher_ ## x
 
 #define REGISTER_HASHER(cls, id, name, size) \
-    Z7_COM7F_IMF2(UInt32, cls::GetDigestSize()) { return size; } \
+    STDMETHODIMP_(UInt32) cls::GetDigestSize() throw() { return size; } \
     static IHasher *CreateHasherSpec() { return new cls(); } \
     static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, size }; \
     struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \

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

@@ -1,11 +1,8 @@
 // StdAfx.h
 
-#ifndef ZIP7_INC_STDAFX_H
-#define ZIP7_INC_STDAFX_H
+#ifndef __STDAFX_H
+#define __STDAFX_H
 
-#if defined(_MSC_VER) && _MSC_VER >= 1800
-#pragma warning(disable : 4464) // relative include path contains '..'
-#endif
 #include "../../Common/Common.h"
 
 #endif

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

@@ -6,48 +6,50 @@
 
 #include "StreamBinder.h"
 
-Z7_CLASS_IMP_COM_1(
-  CBinderInStream
-  , ISequentialInStream
-)
+class CBinderInStream:
+  public ISequentialInStream,
+  public CMyUnknownImp
+{
   CStreamBinder *_binder;
 public:
-  ~CBinderInStream() { _binder->CloseRead_CallOnce(); }
+  MY_UNKNOWN_IMP1(ISequentialInStream)
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  ~CBinderInStream() { _binder->CloseRead(); }
   CBinderInStream(CStreamBinder *binder): _binder(binder) {}
 };
 
-Z7_COM7F_IMF(CBinderInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CBinderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
   { return _binder->Read(data, size, processedSize); }
 
-
-Z7_CLASS_IMP_COM_1(
-  CBinderOutStream
-  , ISequentialOutStream
-)
+class CBinderOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
   CStreamBinder *_binder;
 public:
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   ~CBinderOutStream() { _binder->CloseWrite(); }
   CBinderOutStream(CStreamBinder *binder): _binder(binder) {}
 };
 
-Z7_COM7F_IMF(CBinderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CBinderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
   { return _binder->Write(data, size, processedSize); }
 
 
-static HRESULT Event_Create_or_Reset(NWindows::NSynchronization::CAutoResetEvent &event)
+
+WRes CStreamBinder::CreateEvents()
 {
-  const WRes wres = event.CreateIfNotCreated_Reset();
-  return HRESULT_FROM_WIN32(wres);
+  RINOK(_canWrite_Event.Create());
+  RINOK(_canRead_Event.Create());
+  return _readingWasClosed_Event.Create();
 }
 
-HRESULT CStreamBinder::Create_ReInit()
+void CStreamBinder::ReInit()
 {
-  RINOK(Event_Create_or_Reset(_canRead_Event))
-  // RINOK(Event_Create_or_Reset(_canWrite_Event))
-
-  // _canWrite_Semaphore.Close();
-  // we need at least 3 items of maxCount: 1 for normal unlock in Read(), 2 items for unlock in CloseRead_CallOnce()
-  _canWrite_Semaphore.OptCreateInit(0, 3);
+  _canWrite_Event.Reset();
+  _canRead_Event.Reset();
+  _readingWasClosed_Event.Reset();
 
   // _readingWasClosed = false;
   _readingWasClosed2 = false;
@@ -57,14 +59,27 @@ HRESULT CStreamBinder::Create_ReInit()
   _buf = NULL;
   ProcessedSize = 0;
   // WritingWasCut = false;
-  return S_OK;
 }
 
 
-void CStreamBinder::CreateStreams2(CMyComPtr<ISequentialInStream> &inStream, CMyComPtr<ISequentialOutStream> &outStream)
+void CStreamBinder::CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream)
 {
-  inStream = new CBinderInStream(this);
-  outStream = new CBinderOutStream(this);
+  // _readingWasClosed = false;
+  _readingWasClosed2 = false;
+
+  _waitWrite = true;
+  _bufSize = 0;
+  _buf = NULL;
+  ProcessedSize = 0;
+  // WritingWasCut = false;
+
+  CBinderInStream *inStreamSpec = new CBinderInStream(this);
+  CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
+  *inStream = inStreamLoc.Detach();
+
+  CBinderOutStream *outStreamSpec = new CBinderOutStream(this);
+  CMyComPtr<ISequentialOutStream> outStreamLoc(outStreamSpec);
+  *outStream = outStreamLoc.Detach();
 }
 
 // (_canRead_Event && _bufSize == 0) means that stream is finished.
@@ -77,9 +92,7 @@ HRESULT CStreamBinder::Read(void *data, UInt32 size, UInt32 *processedSize)
   {
     if (_waitWrite)
     {
-      WRes wres = _canRead_Event.Lock();
-      if (wres != 0)
-        return HRESULT_FROM_WIN32(wres);
+      RINOK(_canRead_Event.Lock());
       _waitWrite = false;
     }
     if (size > _bufSize)
@@ -92,25 +105,17 @@ HRESULT CStreamBinder::Read(void *data, UInt32 size, UInt32 *processedSize)
       if (processedSize)
         *processedSize = size;
       _bufSize -= size;
-
-      /*
-      if (_bufSize == 0), then we have read whole buffer
-      we have two ways here:
-        - if we       check (_bufSize == 0) here, we unlock Write only after full data Reading - it reduces the number of syncs
-        - if we don't check (_bufSize == 0) here, we unlock Write after partial data Reading
-      */
       if (_bufSize == 0)
       {
         _waitWrite = true;
-        // _canWrite_Event.Set();
-        _canWrite_Semaphore.Release();
+        _canRead_Event.Reset();
+        _canWrite_Event.Set();
       }
     }
   }
   return S_OK;
 }
 
-
 HRESULT CStreamBinder::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
@@ -130,20 +135,20 @@ HRESULT CStreamBinder::Write(const void *data, UInt32 size, UInt32 *processedSiz
       _readingWasClosed2 = true;
     */
 
-    _canWrite_Semaphore.Lock();
+    HANDLE events[2] = { _canWrite_Event, _readingWasClosed_Event };
+    DWORD waitResult = ::WaitForMultipleObjects(2, events, FALSE, INFINITE);
+    if (waitResult >= WAIT_OBJECT_0 + 2)
+      return E_FAIL;
 
-    // _bufSize : is remain size that was not read
     size -= _bufSize;
-
-    // size : is size of data that was read
     if (size != 0)
     {
-      // if some data was read, then we report that size and return
       if (processedSize)
         *processedSize = size;
       return S_OK;
     }
-    _readingWasClosed2 = true;
+    // if (waitResult == WAIT_OBJECT_0 + 1)
+      _readingWasClosed2 = true;
   }
 
   // WritingWasCut = true;

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

@@ -1,70 +1,52 @@
 // StreamBinder.h
 
-#ifndef ZIP7_INC_STREAM_BINDER_H
-#define ZIP7_INC_STREAM_BINDER_H
+#ifndef __STREAM_BINDER_H
+#define __STREAM_BINDER_H
 
 #include "../../Windows/Synchronization.h"
 
 #include "../IStream.h"
 
 /*
-We can use one from two code versions here: with Event or with Semaphore to unlock Writer thread
-The difference for cases where Reading must be closed before Writing closing
-
-1) Event Version: _canWrite_Event
-  We call _canWrite_Event.Set() without waiting _canRead_Event in CloseRead() function.
-  The writer thread can get (_readingWasClosed) status in one from two iterations.
-  It's ambiguity of processing flow. But probably it's SAFE to use, if Event functions provide memory barriers.
-  reader thread:
+We don't use probably UNSAFE version:
+reader thread:
      _canWrite_Event.Set();
-     _readingWasClosed = true;
+     _readingWasClosed = true
      _canWrite_Event.Set();
-  writer thread:
+writer thread:
      _canWrite_Event.Wait()
       if (_readingWasClosed)
-
-2) Semaphore Version: _canWrite_Semaphore
-  writer thread always will detect closing of reading in latest iteration after all data processing iterations
+Can second call of _canWrite_Event.Set() be executed without memory barrier, if event is already set?
 */
 
 class CStreamBinder
 {
-  NWindows::NSynchronization::CAutoResetEvent _canRead_Event;
-  // NWindows::NSynchronization::CAutoResetEvent _canWrite_Event;
-  NWindows::NSynchronization::CSemaphore _canWrite_Semaphore;
+  NWindows::NSynchronization::CAutoResetEvent _canWrite_Event;
+  NWindows::NSynchronization::CManualResetEvent _canRead_Event;
+  NWindows::NSynchronization::CManualResetEvent _readingWasClosed_Event;
 
-  // bool _readingWasClosed;  // set it in reader thread and check it in write thread
-  bool _readingWasClosed2; // use it in writer thread
+  // bool _readingWasClosed;
+  bool _readingWasClosed2;
   // bool WritingWasCut;
-  bool _waitWrite;         // use it in reader thread
+  bool _waitWrite;
   UInt32 _bufSize;
   const void *_buf;
 public:
-  UInt64 ProcessedSize;   // the size that was read by reader thread
+  UInt64 ProcessedSize;
 
-  void CreateStreams2(CMyComPtr<ISequentialInStream> &inStream, CMyComPtr<ISequentialOutStream> &outStream);
+  WRes CreateEvents();
+  void CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream);
   
-  HRESULT Create_ReInit();
+  void ReInit();
   
   HRESULT Read(void *data, UInt32 size, UInt32 *processedSize);
   HRESULT Write(const void *data, UInt32 size, UInt32 *processedSize);
 
-  void CloseRead_CallOnce()
+  void CloseRead()
   {
-    // call it only once: for example, in destructor
-    
-    /*
-    _readingWasClosed = true;
-    _canWrite_Event.Set();
-    */
-
-    /*
-    We must relase Semaphore only once !!!
-    we must release at least 2 items of Semaphore:
-      one item to unlock partial Write(), if Read() have read some items
-      then additional item to stop writing (_bufSize will be 0)
-    */
-    _canWrite_Semaphore.Release(2);
+    _readingWasClosed_Event.Set();
+    // _readingWasClosed = true;
+    // _canWrite_Event.Set();
   }
   
   void CloseWrite()

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

@@ -2,11 +2,13 @@
 
 #include "StdAfx.h"
 
+#include <stdlib.h>
+
 #include "../../../C/Alloc.h"
 
 #include "StreamObjects.h"
 
-Z7_COM7F_IMF(CBufferInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CBufferInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -24,7 +26,7 @@ Z7_COM7F_IMF(CBufferInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
   return S_OK;
 }
 
-Z7_COM7F_IMF(CBufferInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CBufferInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -35,13 +37,13 @@ Z7_COM7F_IMF(CBufferInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newP
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _pos = (UInt64)offset;
+  _pos = offset;
   if (newPosition)
-    *newPosition = (UInt64)offset;
+    *newPosition = offset;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -59,7 +61,7 @@ Z7_COM7F_IMF(CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
   return S_OK;
 }
 
-Z7_COM7F_IMF(CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -70,9 +72,9 @@ Z7_COM7F_IMF(CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosi
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _pos = (UInt64)offset;
+  _pos = offset;
   if (newPosition)
-    *newPosition = (UInt64)offset;
+    *newPosition = offset;
   return S_OK;
 }
 
@@ -97,8 +99,8 @@ void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequential
 
 void CByteDynBuffer::Free() throw()
 {
-  MyFree(_buf);
-  _buf = NULL;
+  free(_buf);
+  _buf = 0;
   _capacity = 0;
 }
 
@@ -106,10 +108,15 @@ bool CByteDynBuffer::EnsureCapacity(size_t cap) throw()
 {
   if (cap <= _capacity)
     return true;
-  const size_t cap2 = _capacity + _capacity / 4;
-  if (cap < cap2)
-    cap = cap2;
-  Byte *buf = (Byte *)MyRealloc(_buf, cap);
+  size_t delta;
+  if (_capacity > 64)
+    delta = _capacity / 4;
+  else if (_capacity > 8)
+    delta = 16;
+  else
+    delta = 4;
+  cap = MyMax(_capacity + delta, cap);
+  Byte *buf = (Byte *)realloc(_buf, cap);
   if (!buf)
     return false;
   _buf = buf;
@@ -132,7 +139,7 @@ void CDynBufSeqOutStream::CopyToBuffer(CByteBuffer &dest) const
   dest.CopyFrom((const Byte *)_buffer, _size);
 }
 
-Z7_COM7F_IMF(CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -148,7 +155,7 @@ Z7_COM7F_IMF(CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *p
   return S_OK;
 }
 
-Z7_COM7F_IMF(CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   size_t rem = _size - _pos;
   if (rem > size)
@@ -163,7 +170,7 @@ Z7_COM7F_IMF(CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *p
   return (rem != 0 || size == 0) ? S_OK : E_FAIL;
 }
 
-Z7_COM7F_IMF(CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   UInt32 realProcessedSize;
   HRESULT result = _stream->Write(data, size, &realProcessedSize);
@@ -178,9 +185,9 @@ static const UInt64 kEmptyTag = (UInt64)(Int64)-1;
 void CCachedInStream::Free() throw()
 {
   MyFree(_tags);
-  _tags = NULL;
+  _tags = 0;
   MidFree(_data);
-  _data = NULL;
+  _data = 0;
 }
 
 bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw()
@@ -189,19 +196,19 @@ bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw(
   if (sizeLog >= sizeof(size_t) * 8)
     return false;
   size_t dataSize = (size_t)1 << sizeLog;
-  if (!_data || dataSize != _dataSize)
+  if (_data == 0 || dataSize != _dataSize)
   {
     MidFree(_data);
     _data = (Byte *)MidAlloc(dataSize);
-    if (!_data)
+    if (_data == 0)
       return false;
     _dataSize = dataSize;
   }
-  if (!_tags || numBlocksLog != _numBlocksLog)
+  if (_tags == 0 || numBlocksLog != _numBlocksLog)
   {
     MyFree(_tags);
     _tags = (UInt64 *)MyAlloc(sizeof(UInt64) << numBlocksLog);
-    if (!_tags)
+    if (_tags == 0)
       return false;
     _numBlocksLog = numBlocksLog;
   }
@@ -213,12 +220,12 @@ void CCachedInStream::Init(UInt64 size) throw()
 {
   _size = size;
   _pos = 0;
-  const size_t numBlocks = (size_t)1 << _numBlocksLog;
+  size_t numBlocks = (size_t)1 << _numBlocksLog;
   for (size_t i = 0; i < numBlocks; i++)
     _tags[i] = kEmptyTag;
 }
 
-Z7_COM7F_IMF(CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -228,39 +235,28 @@ Z7_COM7F_IMF(CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
     return S_OK;
 
   {
-    const UInt64 rem = _size - _pos;
+    UInt64 rem = _size - _pos;
     if (size > rem)
       size = (UInt32)rem;
   }
 
   while (size != 0)
   {
-    const UInt64 cacheTag = _pos >> _blockSizeLog;
-    const size_t cacheIndex = (size_t)cacheTag & (((size_t)1 << _numBlocksLog) - 1);
+    UInt64 cacheTag = _pos >> _blockSizeLog;
+    size_t cacheIndex = (size_t)cacheTag & (((size_t)1 << _numBlocksLog) - 1);
     Byte *p = _data + (cacheIndex << _blockSizeLog);
-
     if (_tags[cacheIndex] != cacheTag)
     {
-      _tags[cacheIndex] = kEmptyTag;
-      const UInt64 remInBlock = _size - (cacheTag << _blockSizeLog);
+      UInt64 remInBlock = _size - (cacheTag << _blockSizeLog);
       size_t blockSize = (size_t)1 << _blockSizeLog;
       if (blockSize > remInBlock)
         blockSize = (size_t)remInBlock;
-      
-      RINOK(ReadBlock(cacheTag, p, blockSize))
-      
+      RINOK(ReadBlock(cacheTag, p, blockSize));
       _tags[cacheIndex] = cacheTag;
     }
-    
-    const size_t kBlockSize = (size_t)1 << _blockSizeLog;
-    const size_t offset = (size_t)_pos & (kBlockSize - 1);
-    UInt32 cur = size;
-    const size_t rem = kBlockSize - offset;
-    if (cur > rem)
-      cur = (UInt32)rem;
-    
+    size_t offset = (size_t)_pos & (((size_t)1 << _blockSizeLog) - 1);
+    UInt32 cur = (UInt32)MyMin(((size_t)1 << _blockSizeLog) - offset, (size_t)size);
     memcpy(data, p + offset, cur);
-    
     if (processedSize)
       *processedSize += cur;
     data = (void *)((const Byte *)data + cur);
@@ -270,9 +266,8 @@ Z7_COM7F_IMF(CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
 
   return S_OK;
 }
-
  
-Z7_COM7F_IMF(CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition))
+STDMETHODIMP CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
   switch (seekOrigin)
   {
@@ -283,8 +278,8 @@ Z7_COM7F_IMF(CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newP
   }
   if (offset < 0)
     return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _pos = (UInt64)offset;
+  _pos = offset;
   if (newPosition)
-    *newPosition = (UInt64)offset;
+    *newPosition = offset;
   return S_OK;
 }