react-native-update 10.34.6 → 10.34.8

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

@@ -1,78 +0,0 @@
-// RegisterArc.h
-
-#ifndef __REGISTER_ARC_H
-#define __REGISTER_ARC_H
-
-#include "../Archive/IArchive.h"
-
-struct CArcInfo
-{
-  UInt16 Flags;
-  Byte Id;
-  Byte SignatureSize;
-  UInt16 SignatureOffset;
-  
-  const Byte *Signature;
-  const char *Name;
-  const char *Ext;
-  const char *AddExt;
-  
-  Func_CreateInArchive CreateInArchive;
-  Func_CreateOutArchive CreateOutArchive;
-  Func_IsArc IsArc;
-
-  bool IsMultiSignature() const { return (Flags & NArcInfoFlags::kMultiSignature) != 0; }
-};
-
-void RegisterArc(const CArcInfo *arcInfo) throw();
-
-
-#define IMP_CreateArcIn_2(c) \
-  static IInArchive *CreateArc() { return new c; }
-
-#define IMP_CreateArcIn IMP_CreateArcIn_2(CHandler())
-
-#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, 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, 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, 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, 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)
-
-#define REGISTER_ARC_I_NO_SIG(n, e, ae, id, offs, flags, isArc) \
-  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, isArc) \
-  IMP_CreateArcIn \
-  IMP_CreateArcOut \
-  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, isArc) \
-  IMP_CreateArcIn \
-  IMP_CreateArcOut \
-  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;
-
-#endif

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

@@ -1,106 +0,0 @@
-// RegisterCodec.h
-
-#ifndef __REGISTER_CODEC_H
-#define __REGISTER_CODEC_H
-
-#include "../Common/MethodId.h"
-
-#include "../ICoder.h"
-
-typedef void * (*CreateCodecP)();
-
-struct CCodecInfo
-{
-  CreateCodecP CreateDecoder;
-  CreateCodecP CreateEncoder;
-  CMethodId Id;
-  const char *Name;
-  UInt32 NumStreams;
-  bool IsFilter;
-};
-
-void RegisterCodec(const CCodecInfo *codecInfo) throw();
-
-
-#define REGISTER_CODEC_CREATE_2(name, cls, i) static void *name() { return (void *)(i *)(new cls); }
-#define REGISTER_CODEC_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressCoder)
-
-#define REGISTER_CODEC_NAME(x) CRegisterCodec ## 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); }}; \
-    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 < 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 \
-    { crDec, crEnc, id, name, 1, false }; \
-    REGISTER_CODEC(x)
-
-
-#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)
-#else
-  #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
-    REGISTER_CODEC_CREATE(CreateDec, clsDec) \
-    REGISTER_CODEC_CREATE(CreateEnc, clsEnc) \
-    REGISTER_CODEC_2(x, CreateDec, CreateEnc, id, name)
-#endif
-
-
-
-#define REGISTER_FILTER_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressFilter)
-
-#define REGISTER_FILTER_ITEM(crDec, crEnc, id, name) \
-    { crDec, crEnc, id, name, 1, true }
-
-#define REGISTER_FILTER(x, crDec, crEnc, id, name) \
-    REGISTER_CODEC_VAR \
-    REGISTER_FILTER_ITEM(crDec, crEnc, id, name); \
-    REGISTER_CODEC(x)
-
-#ifdef EXTRACT_ONLY
-  #define REGISTER_FILTER_E(x, clsDec, clsEnc, 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(CreateDec, clsDec) \
-    REGISTER_FILTER_CREATE(CreateEnc, clsEnc) \
-    REGISTER_FILTER(x, CreateDec, CreateEnc, id, name)
-#endif
-
-
-
-struct CHasherInfo
-{
-  IHasher * (*CreateHasher)();
-  CMethodId Id;
-  const char *Name;
-  UInt32 DigestSize;
-};
-
-void RegisterHasher(const CHasherInfo *hasher) throw();
-
-#define REGISTER_HASHER_NAME(x) CRegHasher_ ## x
-
-#define REGISTER_HASHER(cls, id, name, 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); }}; \
-    static REGISTER_HASHER_NAME(cls) g_RegisterHasher;
-
-#endif

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

@@ -1,8 +0,0 @@
-// StdAfx.h
-
-#ifndef __STDAFX_H
-#define __STDAFX_H
-
-#include "../../Common/Common.h"
-
-#endif

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

@@ -1,156 +0,0 @@
-// StreamBinder.cpp
-
-#include "StdAfx.h"
-
-#include "../../Common/MyCom.h"
-
-#include "StreamBinder.h"
-
-class CBinderInStream:
-  public ISequentialInStream,
-  public CMyUnknownImp
-{
-  CStreamBinder *_binder;
-public:
-  MY_UNKNOWN_IMP1(ISequentialInStream)
-  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-  ~CBinderInStream() { _binder->CloseRead(); }
-  CBinderInStream(CStreamBinder *binder): _binder(binder) {}
-};
-
-STDMETHODIMP CBinderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-  { return _binder->Read(data, size, processedSize); }
-
-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) {}
-};
-
-STDMETHODIMP CBinderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-  { return _binder->Write(data, size, processedSize); }
-
-
-
-WRes CStreamBinder::CreateEvents()
-{
-  RINOK(_canWrite_Event.Create());
-  RINOK(_canRead_Event.Create());
-  return _readingWasClosed_Event.Create();
-}
-
-void CStreamBinder::ReInit()
-{
-  _canWrite_Event.Reset();
-  _canRead_Event.Reset();
-  _readingWasClosed_Event.Reset();
-
-  // _readingWasClosed = false;
-  _readingWasClosed2 = false;
-
-  _waitWrite = true;
-  _bufSize = 0;
-  _buf = NULL;
-  ProcessedSize = 0;
-  // WritingWasCut = false;
-}
-
-
-void CStreamBinder::CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream)
-{
-  // _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.
-
-HRESULT CStreamBinder::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
-  if (processedSize)
-    *processedSize = 0;
-  if (size != 0)
-  {
-    if (_waitWrite)
-    {
-      RINOK(_canRead_Event.Lock());
-      _waitWrite = false;
-    }
-    if (size > _bufSize)
-      size = _bufSize;
-    if (size != 0)
-    {
-      memcpy(data, _buf, size);
-      _buf = ((const Byte *)_buf) + size;
-      ProcessedSize += size;
-      if (processedSize)
-        *processedSize = size;
-      _bufSize -= size;
-      if (_bufSize == 0)
-      {
-        _waitWrite = true;
-        _canRead_Event.Reset();
-        _canWrite_Event.Set();
-      }
-    }
-  }
-  return S_OK;
-}
-
-HRESULT CStreamBinder::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
-  if (processedSize)
-    *processedSize = 0;
-  if (size == 0)
-    return S_OK;
-
-  if (!_readingWasClosed2)
-  {
-    _buf = data;
-    _bufSize = size;
-    _canRead_Event.Set();
-    
-    /*
-    _canWrite_Event.Lock();
-    if (_readingWasClosed)
-      _readingWasClosed2 = true;
-    */
-
-    HANDLE events[2] = { _canWrite_Event, _readingWasClosed_Event };
-    DWORD waitResult = ::WaitForMultipleObjects(2, events, FALSE, INFINITE);
-    if (waitResult >= WAIT_OBJECT_0 + 2)
-      return E_FAIL;
-
-    size -= _bufSize;
-    if (size != 0)
-    {
-      if (processedSize)
-        *processedSize = size;
-      return S_OK;
-    }
-    // if (waitResult == WAIT_OBJECT_0 + 1)
-      _readingWasClosed2 = true;
-  }
-
-  // WritingWasCut = true;
-  return k_My_HRESULT_WritingWasCut;
-}

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

@@ -1,60 +0,0 @@
-// StreamBinder.h
-
-#ifndef __STREAM_BINDER_H
-#define __STREAM_BINDER_H
-
-#include "../../Windows/Synchronization.h"
-
-#include "../IStream.h"
-
-/*
-We don't use probably UNSAFE version:
-reader thread:
-     _canWrite_Event.Set();
-     _readingWasClosed = true
-     _canWrite_Event.Set();
-writer thread:
-     _canWrite_Event.Wait()
-      if (_readingWasClosed)
-Can second call of _canWrite_Event.Set() be executed without memory barrier, if event is already set?
-*/
-
-class CStreamBinder
-{
-  NWindows::NSynchronization::CAutoResetEvent _canWrite_Event;
-  NWindows::NSynchronization::CManualResetEvent _canRead_Event;
-  NWindows::NSynchronization::CManualResetEvent _readingWasClosed_Event;
-
-  // bool _readingWasClosed;
-  bool _readingWasClosed2;
-  // bool WritingWasCut;
-  bool _waitWrite;
-  UInt32 _bufSize;
-  const void *_buf;
-public:
-  UInt64 ProcessedSize;
-
-  WRes CreateEvents();
-  void CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream);
-  
-  void ReInit();
-  
-  HRESULT Read(void *data, UInt32 size, UInt32 *processedSize);
-  HRESULT Write(const void *data, UInt32 size, UInt32 *processedSize);
-
-  void CloseRead()
-  {
-    _readingWasClosed_Event.Set();
-    // _readingWasClosed = true;
-    // _canWrite_Event.Set();
-  }
-  
-  void CloseWrite()
-  {
-    _buf = NULL;
-    _bufSize = 0;
-    _canRead_Event.Set();
-  }
-};
-
-#endif

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

@@ -1,285 +0,0 @@
-// StreamObjects.cpp
-
-#include "StdAfx.h"
-
-#include <stdlib.h>
-
-#include "../../../C/Alloc.h"
-
-#include "StreamObjects.h"
-
-STDMETHODIMP CBufferInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
-  if (processedSize)
-    *processedSize = 0;
-  if (size == 0)
-    return S_OK;
-  if (_pos >= Buf.Size())
-    return S_OK;
-  size_t rem = Buf.Size() - (size_t)_pos;
-  if (rem > size)
-    rem = (size_t)size;
-  memcpy(data, (const Byte *)Buf + (size_t)_pos, rem);
-  _pos += rem;
-  if (processedSize)
-    *processedSize = (UInt32)rem;
-  return S_OK;
-}
-
-STDMETHODIMP CBufferInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
-  switch (seekOrigin)
-  {
-    case STREAM_SEEK_SET: break;
-    case STREAM_SEEK_CUR: offset += _pos; break;
-    case STREAM_SEEK_END: offset += Buf.Size(); break;
-    default: return STG_E_INVALIDFUNCTION;
-  }
-  if (offset < 0)
-    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _pos = offset;
-  if (newPosition)
-    *newPosition = offset;
-  return S_OK;
-}
-
-STDMETHODIMP CBufInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
-  if (processedSize)
-    *processedSize = 0;
-  if (size == 0)
-    return S_OK;
-  if (_pos >= _size)
-    return S_OK;
-  size_t rem = _size - (size_t)_pos;
-  if (rem > size)
-    rem = (size_t)size;
-  memcpy(data, _data + (size_t)_pos, rem);
-  _pos += rem;
-  if (processedSize)
-    *processedSize = (UInt32)rem;
-  return S_OK;
-}
-
-STDMETHODIMP CBufInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
-  switch (seekOrigin)
-  {
-    case STREAM_SEEK_SET: break;
-    case STREAM_SEEK_CUR: offset += _pos; break;
-    case STREAM_SEEK_END: offset += _size; break;
-    default: return STG_E_INVALIDFUNCTION;
-  }
-  if (offset < 0)
-    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _pos = offset;
-  if (newPosition)
-    *newPosition = offset;
-  return S_OK;
-}
-
-void Create_BufInStream_WithReference(const void *data, size_t size, IUnknown *ref, ISequentialInStream **stream)
-{
-  *stream = NULL;
-  CBufInStream *inStreamSpec = new CBufInStream;
-  CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
-  inStreamSpec->Init((const Byte *)data, size, ref);
-  *stream = streamTemp.Detach();
-}
-
-void Create_BufInStream_WithNewBuffer(const void *data, size_t size, ISequentialInStream **stream)
-{
-  *stream = NULL;
-  CBufferInStream *inStreamSpec = new CBufferInStream;
-  CMyComPtr<ISequentialInStream> streamTemp = inStreamSpec;
-  inStreamSpec->Buf.CopyFrom((const Byte *)data, size);
-  inStreamSpec->Init();
-  *stream = streamTemp.Detach();
-}
-
-void CByteDynBuffer::Free() throw()
-{
-  free(_buf);
-  _buf = 0;
-  _capacity = 0;
-}
-
-bool CByteDynBuffer::EnsureCapacity(size_t cap) throw()
-{
-  if (cap <= _capacity)
-    return true;
-  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;
-  _capacity = cap;
-  return true;
-}
-
-Byte *CDynBufSeqOutStream::GetBufPtrForWriting(size_t addSize)
-{
-  addSize += _size;
-  if (addSize < _size)
-    return NULL;
-  if (!_buffer.EnsureCapacity(addSize))
-    return NULL;
-  return (Byte *)_buffer + _size;
-}
-
-void CDynBufSeqOutStream::CopyToBuffer(CByteBuffer &dest) const
-{
-  dest.CopyFrom((const Byte *)_buffer, _size);
-}
-
-STDMETHODIMP CDynBufSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
-  if (processedSize)
-    *processedSize = 0;
-  if (size == 0)
-    return S_OK;
-  Byte *buf = GetBufPtrForWriting(size);
-  if (!buf)
-    return E_OUTOFMEMORY;
-  memcpy(buf, data, size);
-  UpdateSize(size);
-  if (processedSize)
-    *processedSize = size;
-  return S_OK;
-}
-
-STDMETHODIMP CBufPtrSeqOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
-  size_t rem = _size - _pos;
-  if (rem > size)
-    rem = (size_t)size;
-  if (rem != 0)
-  {
-    memcpy(_buffer + _pos, data, rem);
-    _pos += rem;
-  }
-  if (processedSize)
-    *processedSize = (UInt32)rem;
-  return (rem != 0 || size == 0) ? S_OK : E_FAIL;
-}
-
-STDMETHODIMP CSequentialOutStreamSizeCount::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
-  UInt32 realProcessedSize;
-  HRESULT result = _stream->Write(data, size, &realProcessedSize);
-  _size += realProcessedSize;
-  if (processedSize)
-    *processedSize = realProcessedSize;
-  return result;
-}
-
-static const UInt64 kEmptyTag = (UInt64)(Int64)-1;
-
-void CCachedInStream::Free() throw()
-{
-  MyFree(_tags);
-  _tags = 0;
-  MidFree(_data);
-  _data = 0;
-}
-
-bool CCachedInStream::Alloc(unsigned blockSizeLog, unsigned numBlocksLog) throw()
-{
-  unsigned sizeLog = blockSizeLog + numBlocksLog;
-  if (sizeLog >= sizeof(size_t) * 8)
-    return false;
-  size_t dataSize = (size_t)1 << sizeLog;
-  if (_data == 0 || dataSize != _dataSize)
-  {
-    MidFree(_data);
-    _data = (Byte *)MidAlloc(dataSize);
-    if (_data == 0)
-      return false;
-    _dataSize = dataSize;
-  }
-  if (_tags == 0 || numBlocksLog != _numBlocksLog)
-  {
-    MyFree(_tags);
-    _tags = (UInt64 *)MyAlloc(sizeof(UInt64) << numBlocksLog);
-    if (_tags == 0)
-      return false;
-    _numBlocksLog = numBlocksLog;
-  }
-  _blockSizeLog = blockSizeLog;
-  return true;
-}
-
-void CCachedInStream::Init(UInt64 size) throw()
-{
-  _size = size;
-  _pos = 0;
-  size_t numBlocks = (size_t)1 << _numBlocksLog;
-  for (size_t i = 0; i < numBlocks; i++)
-    _tags[i] = kEmptyTag;
-}
-
-STDMETHODIMP CCachedInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
-  if (processedSize)
-    *processedSize = 0;
-  if (size == 0)
-    return S_OK;
-  if (_pos >= _size)
-    return S_OK;
-
-  {
-    UInt64 rem = _size - _pos;
-    if (size > rem)
-      size = (UInt32)rem;
-  }
-
-  while (size != 0)
-  {
-    UInt64 cacheTag = _pos >> _blockSizeLog;
-    size_t cacheIndex = (size_t)cacheTag & (((size_t)1 << _numBlocksLog) - 1);
-    Byte *p = _data + (cacheIndex << _blockSizeLog);
-    if (_tags[cacheIndex] != cacheTag)
-    {
-      UInt64 remInBlock = _size - (cacheTag << _blockSizeLog);
-      size_t blockSize = (size_t)1 << _blockSizeLog;
-      if (blockSize > remInBlock)
-        blockSize = (size_t)remInBlock;
-      RINOK(ReadBlock(cacheTag, p, blockSize));
-      _tags[cacheIndex] = cacheTag;
-    }
-    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);
-    _pos += cur;
-    size -= cur;
-  }
-
-  return S_OK;
-}
- 
-STDMETHODIMP CCachedInStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
-  switch (seekOrigin)
-  {
-    case STREAM_SEEK_SET: break;
-    case STREAM_SEEK_CUR: offset += _pos; break;
-    case STREAM_SEEK_END: offset += _size; break;
-    default: return STG_E_INVALIDFUNCTION;
-  }
-  if (offset < 0)
-    return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
-  _pos = offset;
-  if (newPosition)
-    *newPosition = offset;
-  return S_OK;
-}