react-native-update 10.34.3 → 10.34.5

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

@@ -16,11 +16,10 @@
 namespace NArchive {
 namespace N7z {
 
-Z7_CLASS_IMP_COM_1(
-  CFolderOutStream
-  , ISequentialOutStream
-  /* , ICompressGetSubStreamSize */
-)
+class CFolderOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
   CMyComPtr<ISequentialOutStream> _stream;
 public:
   bool TestMode;
@@ -32,7 +31,6 @@ private:
   UInt64 _rem;
 
   const UInt32 *_indexes;
-  // unsigned _startIndex;
   unsigned _numFiles;
   unsigned _fileIndex;
 
@@ -42,6 +40,8 @@ private:
   HRESULT ProcessEmptyFiles();
 
 public:
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
+
   const CDbEx *_db;
   CMyComPtr<IArchiveExtractCallback> ExtractCallback;
 
@@ -52,6 +52,8 @@ public:
       CheckCrc(true)
       {}
 
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+
   HRESULT Init(unsigned startIndex, const UInt32 *indexes, unsigned numFiles);
   HRESULT FlushCorrupted(Int32 callbackOperationResult);
 
@@ -61,7 +63,6 @@ public:
 
 HRESULT CFolderOutStream::Init(unsigned startIndex, const UInt32 *indexes, unsigned numFiles)
 {
-  // _startIndex = startIndex;
   _fileIndex = startIndex;
   _indexes = indexes;
   _numFiles = numFiles;
@@ -75,10 +76,11 @@ HRESULT CFolderOutStream::Init(unsigned startIndex, const UInt32 *indexes, unsig
 HRESULT CFolderOutStream::OpenFile(bool isCorrupted)
 {
   const CFileItem &fi = _db->Files[_fileIndex];
-  const UInt32 nextFileIndex = (_indexes ? *_indexes : _fileIndex);
-  Int32 askMode = (_fileIndex == nextFileIndex) ? TestMode ?
-      NExtract::NAskMode::kTest :
-      NExtract::NAskMode::kExtract :
+  UInt32 nextFileIndex = (_indexes ? *_indexes : _fileIndex);
+  Int32 askMode = (_fileIndex == nextFileIndex) ?
+        (TestMode ?
+        NExtract::NAskMode::kTest :
+        NExtract::NAskMode::kExtract) :
       NExtract::NAskMode::kSkip;
 
   if (isCorrupted
@@ -88,7 +90,7 @@ HRESULT CFolderOutStream::OpenFile(bool isCorrupted)
     askMode = NExtract::NAskMode::kTest;
   
   CMyComPtr<ISequentialOutStream> realOutStream;
-  RINOK(ExtractCallback->GetStream(_fileIndex, &realOutStream, askMode))
+  RINOK(ExtractCallback->GetStream(_fileIndex, &realOutStream, askMode));
   
   _stream = realOutStream;
   _crc = CRC_INIT_VAL;
@@ -134,13 +136,13 @@ HRESULT CFolderOutStream::ProcessEmptyFiles()
 {
   while (_numFiles != 0 && _db->Files[_fileIndex].Size == 0)
   {
-    RINOK(OpenFile())
-    RINOK(CloseFile())
+    RINOK(OpenFile());
+    RINOK(CloseFile());
   }
   return S_OK;
 }
 
-Z7_COM7F_IMF(CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -168,16 +170,16 @@ Z7_COM7F_IMF(CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *proc
       _rem -= cur;
       if (_rem == 0)
       {
-        RINOK(CloseFile())
-        RINOK(ProcessEmptyFiles())
+        RINOK(CloseFile());
+        RINOK(ProcessEmptyFiles());
       }
-      RINOK(result)
+      RINOK(result);
       if (cur == 0)
         break;
       continue;
     }
   
-    RINOK(ProcessEmptyFiles())
+    RINOK(ProcessEmptyFiles());
     if (_numFiles == 0)
     {
       // we support partial extracting
@@ -190,7 +192,7 @@ Z7_COM7F_IMF(CFolderOutStream::Write(const void *data, UInt32 size, UInt32 *proc
       // return S_FALSE;
       return k_My_HRESULT_WritingWasCut;
     }
-    RINOK(OpenFile())
+    RINOK(OpenFile());
   }
   
   return S_OK;
@@ -202,37 +204,19 @@ HRESULT CFolderOutStream::FlushCorrupted(Int32 callbackOperationResult)
   {
     if (_fileIsOpen)
     {
-      RINOK(CloseFile_and_SetResult(callbackOperationResult))
+      RINOK(CloseFile_and_SetResult(callbackOperationResult));
     }
     else
     {
-      RINOK(OpenFile(true))
+      RINOK(OpenFile(true));
     }
   }
   return S_OK;
 }
 
-/*
-Z7_COM7F_IMF(CFolderOutStream::GetSubStreamSize(UInt64 subStream, UInt64 *value))
-{
-  *value = 0;
-  // const unsigned numFiles_Original = _numFiles + _fileIndex - _startIndex;
-  const unsigned numFiles_Original = _numFiles;
-  if (subStream >= numFiles_Original)
-    return S_FALSE; // E_FAIL;
-  *value = _db->Files[_startIndex + (unsigned)subStream].Size;
-  return S_OK;
-}
-*/
-
-
-Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
-    Int32 testModeSpec, IArchiveExtractCallback *extractCallbackSpec))
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testModeSpec, IArchiveExtractCallback *extractCallbackSpec)
 {
-  // for GCC
-  // CFolderOutStream *folderOutStream = new CFolderOutStream;
-  // CMyComPtr<ISequentialOutStream> outStream(folderOutStream);
-
   COM_TRY_BEGIN
   
   CMyComPtr<IArchiveExtractCallback> extractCallback = extractCallbackSpec;
@@ -241,7 +225,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
   // numItems = (UInt32)(Int32)-1;
 
-  const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
   if (allFilesMode)
     numItems = _db.Files.Size();
 
@@ -256,8 +240,8 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     
     for (i = 0; i < numItems; i++)
     {
-      const UInt32 fileIndex = allFilesMode ? i : indices[i];
-      const CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
+      UInt32 fileIndex = allFilesMode ? i : indices[i];
+      CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
       if (folderIndex == kNumNoIndex)
         continue;
       if (folderIndex != prevFolder || fileIndex < nextFile)
@@ -269,9 +253,10 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     }
   }
 
-  RINOK(extractCallback->SetTotal(importantTotalUnpacked))
+  RINOK(extractCallback->SetTotal(importantTotalUnpacked));
 
-  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
   lps->Init(extractCallback, false);
 
   CDecoder decoder(
@@ -279,8 +264,8 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       false
     #elif !defined(USE_MIXER_ST)
       true
-    #elif !defined(Z7_7Z_SET_PROPERTIES)
-      #ifdef Z7_ST
+    #elif !defined(__7Z_SET_PROPERTIES)
+      #ifdef _7ZIP_ST
         false
       #else
         true
@@ -292,8 +277,8 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
   UInt64 curPacked, curUnpacked;
 
-  CMyComPtr<IArchiveExtractCallbackMessage2> callbackMessage;
-  extractCallback.QueryInterface(IID_IArchiveExtractCallbackMessage2, &callbackMessage);
+  CMyComPtr<IArchiveExtractCallbackMessage> callbackMessage;
+  extractCallback.QueryInterface(IID_IArchiveExtractCallbackMessage, &callbackMessage);
 
   CFolderOutStream *folderOutStream = new CFolderOutStream;
   CMyComPtr<ISequentialOutStream> outStream(folderOutStream);
@@ -305,7 +290,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
   for (UInt32 i = 0;; lps->OutSize += curUnpacked, lps->InSize += curPacked)
   {
-    RINOK(lps->SetCur())
+    RINOK(lps->SetCur());
 
     if (i >= numItems)
       break;
@@ -314,7 +299,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     curPacked = 0;
 
     UInt32 fileIndex = allFilesMode ? i : indices[i];
-    const CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
+    CNum folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
 
     UInt32 numSolidFiles = 1;
 
@@ -327,7 +312,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
       for (k = i + 1; k < numItems; k++)
       {
-        const UInt32 fileIndex2 = allFilesMode ? k : indices[k];
+        UInt32 fileIndex2 = allFilesMode ? k : indices[k];
         if (_db.FileIndexToFolderIndexMap[fileIndex2] != folderIndex
             || fileIndex2 < nextFile)
           break;
@@ -341,26 +326,20 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     }
 
     {
-      const HRESULT result = folderOutStream->Init(fileIndex,
+      HRESULT result = folderOutStream->Init(fileIndex,
           allFilesMode ? NULL : indices + i,
           numSolidFiles);
 
       i += numSolidFiles;
 
-      RINOK(result)
+      RINOK(result);
     }
 
+    // to test solid block with zero unpacked size we disable that code
     if (folderOutStream->WasWritingFinished())
-    {
-      // for debug: to test zero size stream unpacking
-      // if (folderIndex == kNumNoIndex)  // enable this check for debug
       continue;
-    }
 
-    if (folderIndex == kNumNoIndex)
-      return E_FAIL;
-
-    #ifndef Z7_NO_CRYPTO
+    #ifndef _NO_CRYPTO
     CMyComPtr<ICryptoGetTextPassword> getTextPassword;
     if (extractCallback)
       extractCallback.QueryInterface(IID_ICryptoGetTextPassword, &getTextPassword);
@@ -368,15 +347,16 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 
     try
     {
-      #ifndef Z7_NO_CRYPTO
+      #ifndef _NO_CRYPTO
         bool isEncrypted = false;
         bool passwordIsDefined = false;
-        UString_Wipe password;
+        UString password;
       #endif
 
+
       bool dataAfterEnd_Error = false;
 
-      const HRESULT result = decoder.Decode(
+      HRESULT result = decoder.Decode(
           EXTERNAL_CODECS_VARS
           _inStream,
           _db.ArcInfo.DataStartPosition,
@@ -384,19 +364,19 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           &curUnpacked,
 
           outStream,
-          lps,
+          progress,
           NULL // *inStreamMainRes
           , dataAfterEnd_Error
           
-          Z7_7Z_DECODER_CRYPRO_VARS
-          #if !defined(Z7_ST)
-            , true, _numThreads, _memUsage_Decompress
+          _7Z_DECODER_CRYPRO_VARS
+          #if !defined(_7ZIP_ST)
+            , true, _numThreads, _memUsage
           #endif
           );
 
       if (result == S_FALSE || result == E_NOTIMPL || dataAfterEnd_Error)
       {
-        const bool wasFinished = folderOutStream->WasWritingFinished();
+        bool wasFinished = folderOutStream->WasWritingFinished();
 
         int resOp = NExtract::NOperationResult::kDataError;
         
@@ -408,14 +388,14 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
             resOp = NExtract::NOperationResult::kDataAfterEnd;
         }
 
-        RINOK(folderOutStream->FlushCorrupted(resOp))
+        RINOK(folderOutStream->FlushCorrupted(resOp));
 
         if (wasFinished)
         {
           // we don't show error, if it's after required files
           if (/* !folderOutStream->ExtraWriteWasCut && */ callbackMessage)
           {
-            RINOK(callbackMessage->ReportExtractResult(NEventIndexType::kBlockIndex, folderIndex, resOp))
+            RINOK(callbackMessage->ReportExtractResult(NEventIndexType::kBlockIndex, folderIndex, resOp));
           }
         }
         continue;
@@ -424,15 +404,14 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       if (result != S_OK)
         return result;
 
-      RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError))
+      RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError));
       continue;
     }
     catch(...)
     {
-      RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError))
+      RINOK(folderOutStream->FlushCorrupted(NExtract::NOperationResult::kDataError));
       // continue;
-      // return E_FAIL;
-      throw;
+      return E_FAIL;
     }
   }
 

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

@@ -2,8 +2,6 @@
 
 #include "StdAfx.h"
 
-#include "../../../Windows/TimeUtils.h"
-
 #include "7zFolderInStream.h"
 
 namespace NArchive {
@@ -15,129 +13,66 @@ void CFolderInStream::Init(IArchiveUpdateCallback *updateCallback,
   _updateCallback = updateCallback;
   _indexes = indexes;
   _numFiles = numFiles;
-
-  _totalSize_for_Coder = 0;
-  ClearFileInfo();
+  _index = 0;
   
   Processed.ClearAndReserve(numFiles);
-  Sizes.ClearAndReserve(numFiles);
   CRCs.ClearAndReserve(numFiles);
-  TimesDefined.ClearAndReserve(numFiles);
-  MTimes.ClearAndReserve(Need_MTime ? numFiles : (unsigned)0);
-  CTimes.ClearAndReserve(Need_CTime ? numFiles : (unsigned)0);
-  ATimes.ClearAndReserve(Need_ATime ? numFiles : (unsigned)0);
-  Attribs.ClearAndReserve(Need_Attrib ? numFiles : (unsigned)0);
+  Sizes.ClearAndReserve(numFiles);
+  
+  _pos = 0;
+  _crc = CRC_INIT_VAL;
+  _size_Defined = false;
+  _size = 0;
 
-  // FolderCrc = CRC_INIT_VAL;
   _stream.Release();
 }
 
-void CFolderInStream::ClearFileInfo()
+HRESULT CFolderInStream::OpenStream()
 {
   _pos = 0;
   _crc = CRC_INIT_VAL;
   _size_Defined = false;
-  _times_Defined = false;
   _size = 0;
-  FILETIME_Clear(_mTime);
-  FILETIME_Clear(_cTime);
-  FILETIME_Clear(_aTime);
-  _attrib = 0;
-}
 
-HRESULT CFolderInStream::OpenStream()
-{
-  while (Processed.Size() < _numFiles)
+  while (_index < _numFiles)
   {
     CMyComPtr<ISequentialInStream> stream;
-    const HRESULT result = _updateCallback->GetStream(_indexes[Processed.Size()], &stream);
-    if (result != S_OK && result != S_FALSE)
-      return result;
+    HRESULT result = _updateCallback->GetStream(_indexes[_index], &stream);
+    if (result != S_OK)
+    {
+      if (result != S_FALSE)
+        return result;
+    }
 
     _stream = stream;
     
     if (stream)
     {
+      CMyComPtr<IStreamGetSize> streamGetSize;
+      stream.QueryInterface(IID_IStreamGetSize, &streamGetSize);
+      if (streamGetSize)
       {
-        CMyComPtr<IStreamGetProps> getProps;
-        stream.QueryInterface(IID_IStreamGetProps, (void **)&getProps);
-        if (getProps)
-        {
-          // access could be changed in first myx pass
-          if (getProps->GetProps(&_size,
-              Need_CTime ? &_cTime : NULL,
-              Need_ATime ? &_aTime : NULL,
-              Need_MTime ? &_mTime : NULL,
-              Need_Attrib ? &_attrib : NULL)
-              == S_OK)
-          {
-            _size_Defined = true;
-            _times_Defined = true;
-          }
-          return S_OK;
-        }
-      }
-      {
-        CMyComPtr<IStreamGetSize> streamGetSize;
-        stream.QueryInterface(IID_IStreamGetSize, &streamGetSize);
-        if (streamGetSize)
-        {
-          if (streamGetSize->GetSize(&_size) == S_OK)
-            _size_Defined = true;
-        }
-        return S_OK;
+        if (streamGetSize->GetSize(&_size) == S_OK)
+          _size_Defined = true;
       }
+      return S_OK;
     }
     
-    RINOK(AddFileInfo(result == S_OK))
+    _index++;
+    RINOK(_updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
+    AddFileInfo(result == S_OK);
   }
   return S_OK;
 }
 
-static void AddFt(CRecordVector<UInt64> &vec, const FILETIME &ft)
+void CFolderInStream::AddFileInfo(bool isProcessed)
 {
-  vec.AddInReserved(FILETIME_To_UInt64(ft));
+  Processed.Add(isProcessed);
+  Sizes.Add(_pos);
+  CRCs.Add(CRC_GET_DIGEST(_crc));
 }
 
-/*
-HRESULT ReportItemProps(IArchiveUpdateCallbackArcProp *reportArcProp,
-    UInt32 index, UInt64 size, const UInt32 *crc)
-{
-  PROPVARIANT prop;
-  prop.vt = VT_EMPTY;
-  prop.wReserved1 = 0;
-  
-  NWindows::NCOM::PropVarEm_Set_UInt64(&prop, size);
-  RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidSize, &prop));
-  if (crc)
-  {
-    NWindows::NCOM::PropVarEm_Set_UInt32(&prop, *crc);
-    RINOK(reportArcProp->ReportProp(NEventIndexType::kOutArcIndex, index, kpidCRC, &prop));
-  }
-  return reportArcProp->ReportFinished(NEventIndexType::kOutArcIndex, index, NUpdate::NOperationResult::kOK);
-}
-*/
-
-HRESULT CFolderInStream::AddFileInfo(bool isProcessed)
-{
-  // const UInt32 index = _indexes[Processed.Size()];
-  Processed.AddInReserved(isProcessed);
-  Sizes.AddInReserved(_pos);
-  CRCs.AddInReserved(CRC_GET_DIGEST(_crc));
-  if (Need_Attrib) Attribs.AddInReserved(_attrib);
-  TimesDefined.AddInReserved(_times_Defined);
-  if (Need_MTime) AddFt(MTimes, _mTime);
-  if (Need_CTime) AddFt(CTimes, _cTime);
-  if (Need_ATime) AddFt(ATimes, _aTime);
-  ClearFileInfo();
-  /*
-  if (isProcessed && _reportArcProp)
-    RINOK(ReportItemProps(_reportArcProp, index, _pos, &crc))
-  */
-  return _updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK);
-}
-
-Z7_COM7F_IMF(CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -145,65 +80,46 @@ Z7_COM7F_IMF(CFolderInStream::Read(void *data, UInt32 size, UInt32 *processedSiz
   {
     if (_stream)
     {
-      /*
-      if (_pos == 0)
-      {
-        const UInt32 align = (UInt32)1 << AlignLog;
-        const UInt32 offset = (UInt32)_totalSize_for_Coder & (align - 1);
-        if (offset != 0)
-        {
-          UInt32 cur = align - offset;
-          if (cur > size)
-            cur = size;
-          memset(data, 0, cur);
-          data = (Byte *)data + cur;
-          size -= cur;
-          // _pos += cur; // for debug
-          _totalSize_for_Coder += cur;
-          if (processedSize)
-            *processedSize += cur;
-          continue;
-        }
-      }
-      */
       UInt32 cur = size;
       const UInt32 kMax = (UInt32)1 << 20;
       if (cur > kMax)
         cur = kMax;
-      RINOK(_stream->Read(data, cur, &cur))
+      RINOK(_stream->Read(data, cur, &cur));
       if (cur != 0)
       {
-        // if (Need_Crc)
         _crc = CrcUpdate(_crc, data, cur);
-        /*
-        if (FolderCrc)
-          FolderCrc = CrcUpdate(FolderCrc, data, cur);
-        */
         _pos += cur;
-        _totalSize_for_Coder += cur;
         if (processedSize)
-          *processedSize = cur; // use +=cur, if continue is possible in loop
+          *processedSize = cur;
         return S_OK;
       }
       
       _stream.Release();
-      RINOK(AddFileInfo(true))
+      _index++;
+      AddFileInfo(true);
+
+      _pos = 0;
+      _crc = CRC_INIT_VAL;
+      _size_Defined = false;
+      _size = 0;
+
+      RINOK(_updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
     }
     
-    if (Processed.Size() >= _numFiles)
+    if (_index >= _numFiles)
       break;
-    RINOK(OpenStream())
+    RINOK(OpenStream());
   }
   return S_OK;
 }
 
-Z7_COM7F_IMF(CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value))
+STDMETHODIMP CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value)
 {
   *value = 0;
   if (subStream > Sizes.Size())
     return S_FALSE; // E_FAIL;
   
-  const unsigned index = (unsigned)subStream;
+  unsigned index = (unsigned)subStream;
   if (index < Sizes.Size())
   {
     *value = Sizes[index];
@@ -220,45 +136,4 @@ Z7_COM7F_IMF(CFolderInStream::GetSubStreamSize(UInt64 subStream, UInt64 *value))
   return S_OK;
 }
 
-
-/*
-HRESULT CFolderInStream::CloseCrcStream()
-{
-  if (!_crcStream)
-    return S_OK;
-  if (!_crcStream_Spec->WasFinished())
-    return E_FAIL;
-  _crc = _crcStream_Spec->GetCRC() ^ CRC_INIT_VAL; // change it
-  const UInt64 size = _crcStream_Spec->GetSize();
-  _pos = size;
-  _totalSize_for_Coder += size;
-  _crcStream.Release();
-  // _crcStream->ReleaseStream();
-  _stream.Release();
-  return AddFileInfo(true);
-}
-
-Z7_COM7F_IMF(CFolderInStream::GetNextInSubStream(UInt64 *streamIndexRes, ISequentialInStream **stream)
-{
-  RINOK(CloseCrcStream())
-  *stream = NULL;
-  *streamIndexRes = Processed.Size();
-  if (Processed.Size() >= _numFiles)
-    return S_OK;
-  RINOK(OpenStream());
-  if (!_stream)
-    return S_OK;
-  if (!_crcStream)
-  {
-    _crcStream_Spec = new CSequentialInStreamWithCRC;
-    _crcStream = _crcStream_Spec;
-  }
-  _crcStream_Spec->Init();
-  _crcStream_Spec->SetStream(_stream);
-  *stream = _crcStream;
-  _crcStream->AddRef();
-  return S_OK;
-}
-*/
-
 }}