react-native-update 10.34.3 → 10.34.4

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

@@ -11,9 +11,6 @@
 #include "../../../../C/7zCrc.h"
 #include "../../../../C/CpuArch.h"
 
-#include "../../../Common/MyBuffer2.h"
-// #include "../../../Common/UTFConvert.h"
-
 #include "../../Common/StreamObjects.h"
 #include "../../Common/StreamUtils.h"
 
@@ -25,62 +22,46 @@
 #define Get64(p) GetUi64(p)
 
 // define FORMAT_7Z_RECOVERY if you want to recover multivolume archives with empty StartHeader
-#ifndef Z7_SFX
+#ifndef _SFX
 #define FORMAT_7Z_RECOVERY
 #endif
 
 using namespace NWindows;
 using namespace NCOM;
 
-unsigned BoolVector_CountSum(const CBoolVector &v);
-Z7_NO_INLINE
+namespace NArchive {
+namespace N7z {
+
 unsigned BoolVector_CountSum(const CBoolVector &v)
 {
   unsigned sum = 0;
   const unsigned size = v.Size();
-  if (size)
-  {
-    const bool *p = v.ConstData();
-    const bool * const lim = p + size;
-    do
-     if (*p)
-       sum++;
-    while (++p != lim);
-  }
+  for (unsigned i = 0; i < size; i++)
+    if (v[i])
+      sum++;
   return sum;
 }
 
 static inline bool BoolVector_Item_IsValidAndTrue(const CBoolVector &v, unsigned i)
 {
-  return i < v.Size() ? v[i] : false;
+  return (i < v.Size() ? v[i] : false);
 }
 
-Z7_NO_INLINE
 static void BoolVector_Fill_False(CBoolVector &v, unsigned size)
 {
   v.ClearAndSetSize(size);
-  bool *p = v.NonConstData();
+  bool *p = &v[0];
   for (unsigned i = 0; i < size; i++)
     p[i] = false;
 }
 
 
-namespace NArchive {
-namespace N7z {
-
-#define k_Scan_NumCoders_MAX 64
-#define k_Scan_NumCodersStreams_in_Folder_MAX 64
-
 class CInArchiveException {};
 class CUnsupportedFeatureException: public CInArchiveException {};
 
-Z7_ATTR_NORETURN
 static void ThrowException() { throw CInArchiveException(); }
-Z7_ATTR_NORETURN
 static inline void ThrowEndOfData()   { ThrowException(); }
-Z7_ATTR_NORETURN
 static inline void ThrowUnsupported() { throw CUnsupportedFeatureException(); }
-Z7_ATTR_NORETURN
 static inline void ThrowIncorrect()   { ThrowException(); }
 
 class CStreamSwitch
@@ -125,12 +106,12 @@ void CStreamSwitch::Set(CInArchive *archive, const CByteBuffer &byteBuffer)
 void CStreamSwitch::Set(CInArchive *archive, const CObjectVector<CByteBuffer> *dataVector)
 {
   Remove();
-  const Byte external = archive->ReadByte();
+  Byte external = archive->ReadByte();
   if (external != 0)
   {
     if (!dataVector)
       ThrowIncorrect();
-    const CNum dataIndex = archive->ReadNum();
+    CNum dataIndex = archive->ReadNum();
     if (dataIndex >= dataVector->Size())
       ThrowIncorrect();
     Set(archive, (*dataVector)[dataIndex]);
@@ -183,7 +164,7 @@ static UInt64 ReadNumberSpec(const Byte *p, size_t size, size_t &processed)
     return 0;
   }
   
-  const unsigned b = *p++;
+  unsigned b = *p++;
   size--;
   
   if ((b & 0x80) == 0)
@@ -204,10 +185,10 @@ static UInt64 ReadNumberSpec(const Byte *p, size_t size, size_t &processed)
   
   for (unsigned i = 1; i < 8; i++)
   {
-    const unsigned mask = (unsigned)0x80 >> i;
+    unsigned mask = (unsigned)0x80 >> i;
     if ((b & mask) == 0)
     {
-      const UInt64 high = b & (mask - 1);
+      UInt64 high = b & (mask - 1);
       value |= (high << (i * 8));
       processed = i + 1;
       return value;
@@ -231,7 +212,7 @@ static UInt64 ReadNumberSpec(const Byte *p, size_t size, size_t &processed)
 UInt64 CInByte2::ReadNumber()
 {
   size_t processed;
-  const UInt64 res = ReadNumberSpec(_buffer + _pos, _size - _pos, processed);
+  UInt64 res = ReadNumberSpec(_buffer + _pos, _size - _pos, processed);
   if (processed == 0)
     ThrowEndOfData();
   _pos += processed;
@@ -251,7 +232,7 @@ CNum CInByte2::ReadNum()
     }
   }
   */
-  const UInt64 value = ReadNumber();
+  UInt64 value = ReadNumber();
   if (value > kNumMax)
     ThrowUnsupported();
   return (CNum)value;
@@ -261,7 +242,7 @@ UInt32 CInByte2::ReadUInt32()
 {
   if (_pos + 4 > _size)
     ThrowEndOfData();
-  const UInt32 res = Get32(_buffer + _pos);
+  UInt32 res = Get32(_buffer + _pos);
   _pos += 4;
   return res;
 }
@@ -270,101 +251,54 @@ UInt64 CInByte2::ReadUInt64()
 {
   if (_pos + 8 > _size)
     ThrowEndOfData();
-  const UInt64 res = Get64(_buffer + _pos);
+  UInt64 res = Get64(_buffer + _pos);
   _pos += 8;
   return res;
 }
 
-#define Y0  '7'
-#define Y1  'z'
-#define Y2  0xBC
-#define Y3  0xAF
-#define Y4  0x27
-#define Y5  0x1C
-
-#define IS_SIGNATURE(p)( \
-        (p)[2] == Y2 &&  \
-        (p)[3] == Y3 &&  \
-        (p)[5] == Y5 &&  \
-        (p)[4] == Y4 &&  \
-        (p)[1] == Y1 &&  \
-        (p)[0] == Y0)
-
-/* FindSignature_10() is allowed to access data up to and including &limit[9].
-   limit[10] access is not allowed.
-  return:
-    (return_ptr <  limit) : signature was found at (return_ptr)
-    (return_ptr >= limit) : limit was reached or crossed. So no signature found before limit
-*/
-Z7_NO_INLINE
-static const Byte *FindSignature_10(const Byte *p, const Byte *limit)
-{
-  for (;;)
-  {
-    for (;;)
-    {
-      if (p >= limit)
-        return limit;
-      const Byte b = p[5];
-      p += 6;
-      if (b == Y0) {         break; }
-      if (b == Y1) { p -= 1; break; }
-      if (b == Y2) { p -= 2; break; }
-      if (b == Y3) { p -= 3; break; }
-      if (b == Y4) { p -= 4; break; }
-      if (b == Y5) { p -= 5; break; }
-    }
-    if (IS_SIGNATURE(p - 1))
-      return p - 1;
-  }
-}
-
+#define CHECK_SIGNATURE if (p[0] != '7' || p[1] != 'z' || p[2] != 0xBC || p[3] != 0xAF || p[4] != 0x27 || p[5] != 0x1C) return false;
 
-static inline bool TestStartCrc(const Byte *p)
+static inline bool TestSignature(const Byte *p)
 {
+  CHECK_SIGNATURE
   return CrcCalc(p + 12, 20) == Get32(p + 8);
 }
 
+#ifdef FORMAT_7Z_RECOVERY
 static inline bool TestSignature2(const Byte *p)
 {
-  if (!IS_SIGNATURE(p))
-    return false;
- #ifdef FORMAT_7Z_RECOVERY
-  if (TestStartCrc(p))
+  CHECK_SIGNATURE;
+  if (CrcCalc(p + 12, 20) == Get32(p + 8))
     return true;
   for (unsigned i = 8; i < kHeaderSize; i++)
     if (p[i] != 0)
       return false;
   return (p[6] != 0 || p[7] != 0);
- #else
-  return TestStartCrc(p);
- #endif
 }
-
+#else
+#define TestSignature2(p) TestSignature(p)
+#endif
 
 HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
 {
-  RINOK(ReadStream_FALSE(stream, _header, kHeaderSize))
+  RINOK(ReadStream_FALSE(stream, _header, kHeaderSize));
 
   if (TestSignature2(_header))
     return S_OK;
   if (searchHeaderSizeLimit && *searchHeaderSizeLimit == 0)
     return S_FALSE;
 
-  const UInt32 kBufSize = (1 << 15) + kHeaderSize;  // must be > (kHeaderSize * 2)
-  CAlignedBuffer1 buf(kBufSize);
+  const UInt32 kBufSize = 1 << 15;
+  CByteArr buf(kBufSize);
   memcpy(buf, _header, kHeaderSize);
   UInt64 offset = 0;
   
   for (;;)
   {
-    UInt32 readSize =
-        (offset == 0) ?
-          kBufSize - kHeaderSize - kHeaderSize :
-          kBufSize - kHeaderSize;
+    UInt32 readSize = kBufSize - kHeaderSize;
     if (searchHeaderSizeLimit)
     {
-      const UInt64 rem = *searchHeaderSizeLimit - offset;
+      UInt64 rem = *searchHeaderSizeLimit - offset;
       if (readSize > rem)
         readSize = (UInt32)rem;
       if (readSize == 0)
@@ -372,28 +306,29 @@ HRESULT CInArchive::FindAndReadSignature(IInStream *stream, const UInt64 *search
     }
     
     UInt32 processed = 0;
-    RINOK(stream->Read(buf + kHeaderSize, readSize, &processed))
+    RINOK(stream->Read(buf + kHeaderSize, readSize, &processed));
     if (processed == 0)
       return S_FALSE;
-
-    /* &buf[0] was already tested for signature before.
-       So first search here will be for &buf[1] */
     
     for (UInt32 pos = 0;;)
     {
       const Byte *p = buf + pos + 1;
-      const Byte *lim = buf + processed + 1;
-      /* we have (kHeaderSize - 1 = 31) filled bytes starting from (lim),
-         and it's safe to access just 10 bytes in that reserved area */
-      p = FindSignature_10(p, lim);
-      if (p >= lim)
+      const Byte *lim = buf + processed;
+      for (; p <= lim; p += 4)
+      {
+        if (p[0] == '7') break;
+        if (p[1] == '7') { p += 1; break; }
+        if (p[2] == '7') { p += 2; break; }
+        if (p[3] == '7') { p += 3; break; }
+      };
+      if (p > lim)
         break;
       pos = (UInt32)(p - buf);
-      if (TestStartCrc(p))
+      if (TestSignature(p))
       {
         memcpy(_header, p, kHeaderSize);
         _arhiveBeginStreamPosition += offset + pos;
-        return InStream_SeekSet(stream, _arhiveBeginStreamPosition + kHeaderSize);
+        return stream->Seek(_arhiveBeginStreamPosition + kHeaderSize, STREAM_SEEK_SET, NULL);
       }
     }
     
@@ -407,8 +342,10 @@ HRESULT CInArchive::Open(IInStream *stream, const UInt64 *searchHeaderSizeLimit)
 {
   HeadersSize = 0;
   Close();
-  RINOK(InStream_GetPos_GetSize(stream, _arhiveBeginStreamPosition, _fileEndPosition))
-  RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit))
+  RINOK(stream->Seek(0, STREAM_SEEK_CUR, &_arhiveBeginStreamPosition))
+  RINOK(stream->Seek(0, STREAM_SEEK_END, &_fileEndPosition))
+  RINOK(stream->Seek(_arhiveBeginStreamPosition, STREAM_SEEK_SET, NULL))
+  RINOK(FindAndReadSignature(stream, searchHeaderSizeLimit));
   _stream = stream;
   return S_OK;
 }
@@ -434,9 +371,9 @@ void CInArchive::ReadArchiveProperties(CInArchiveInfo & /* archiveInfo */)
 
 void CInByte2::ParseFolder(CFolder &folder)
 {
-  const UInt32 numCoders = ReadNum();
+  UInt32 numCoders = ReadNum();
 
-  if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)
+  if (numCoders == 0)
     ThrowUnsupported();
 
   folder.Coders.SetSize(numCoders);
@@ -447,10 +384,10 @@ void CInByte2::ParseFolder(CFolder &folder)
   {
     CCoderInfo &coder = folder.Coders[i];
     {
-      const Byte mainByte = ReadByte();
+      Byte mainByte = ReadByte();
       if ((mainByte & 0xC0) != 0)
         ThrowUnsupported();
-      const unsigned idSize = (mainByte & 0xF);
+      unsigned idSize = (mainByte & 0xF);
       if (idSize > 8 || idSize > GetRem())
         ThrowUnsupported();
       const Byte *longID = GetPtr();
@@ -463,9 +400,7 @@ void CInByte2::ParseFolder(CFolder &folder)
       if ((mainByte & 0x10) != 0)
       {
         coder.NumStreams = ReadNum();
-        // if (coder.NumStreams > k_Scan_NumCodersStreams_in_Folder_MAX) ThrowUnsupported();
         /* numOutStreams = */ ReadNum();
-        // if (ReadNum() != 1) // numOutStreams ThrowUnsupported();
       }
       else
       {
@@ -474,7 +409,7 @@ void CInByte2::ParseFolder(CFolder &folder)
       
       if ((mainByte & 0x20) != 0)
       {
-        const CNum propsSize = ReadNum();
+        CNum propsSize = ReadNum();
         coder.Props.Alloc((size_t)propsSize);
         ReadBytes((Byte *)coder.Props, (size_t)propsSize);
       }
@@ -484,7 +419,7 @@ void CInByte2::ParseFolder(CFolder &folder)
     numInStreams += coder.NumStreams;
   }
 
-  const UInt32 numBonds = numCoders - 1;
+  UInt32 numBonds = numCoders - 1;
   folder.Bonds.SetSize(numBonds);
   for (i = 0; i < numBonds; i++)
   {
@@ -495,7 +430,7 @@ void CInByte2::ParseFolder(CFolder &folder)
 
   if (numInStreams < numBonds)
     ThrowUnsupported();
-  const UInt32 numPackStreams = numInStreams - numBonds;
+  UInt32 numPackStreams = numInStreams - numBonds;
   folder.PackStreams.SetSize(numPackStreams);
   
   if (numPackStreams == 1)
@@ -516,9 +451,9 @@ void CInByte2::ParseFolder(CFolder &folder)
 
 void CFolders::ParseFolderInfo(unsigned folderIndex, CFolder &folder) const
 {
-  const size_t startPos = FoCodersDataOffset[folderIndex];
+  size_t startPos = FoCodersDataOffset[folderIndex];
   CInByte2 inByte;
-  inByte.Init(CodersData.ConstData() + startPos, FoCodersDataOffset[folderIndex + 1] - startPos);
+  inByte.Init(CodersData + startPos, FoCodersDataOffset[folderIndex + 1] - startPos);
   inByte.ParseFolder(folder);
   if (inByte.GetRem() != 0)
     throw 20120424;
@@ -531,8 +466,8 @@ void CDatabase::GetPath(unsigned index, UString &path) const
   if (!NameOffsets || !NamesBuf)
     return;
 
-  const size_t offset = NameOffsets[index];
-  const size_t size = NameOffsets[index + 1] - offset;
+  size_t offset = NameOffsets[index];
+  size_t size = NameOffsets[index + 1] - offset;
 
   if (size >= (1 << 28))
     return;
@@ -543,7 +478,7 @@ void CDatabase::GetPath(unsigned index, UString &path) const
 
   #if defined(_WIN32) && defined(MY_CPU_LE)
   
-  wmemcpy(s, (const wchar_t *)(const void *)p, size);
+  wmemcpy(s, (const wchar_t *)p, size);
   
   #else
 
@@ -565,33 +500,16 @@ HRESULT CDatabase::GetPath_Prop(unsigned index, PROPVARIANT *path) const throw()
   if (!NameOffsets || !NamesBuf)
     return S_OK;
 
-  const size_t offset = NameOffsets[index];
-  const size_t size = NameOffsets[index + 1] - offset;
+  size_t offset = NameOffsets[index];
+  size_t size = NameOffsets[index + 1] - offset;
 
   if (size >= (1 << 14))
     return S_OK;
 
-  // (size) includes null terminator
-
-  /*
-  #if WCHAR_MAX > 0xffff
-  
-  const Byte *p = ((const Byte *)NamesBuf + offset * 2);
-  size = Utf16LE__Get_Num_WCHARs(p, size - 1);
-  // (size) doesn't include null terminator
-  RINOK(PropVarEm_Alloc_Bstr(path, (unsigned)size));
+  RINOK(PropVarEm_Alloc_Bstr(path, (unsigned)size - 1));
   wchar_t *s = path->bstrVal;
-  wchar_t *sEnd = Utf16LE__To_WCHARs_Sep(p, size, s);
-  *sEnd = 0;
-  if (s + size != sEnd) return E_FAIL;
 
-  #else
-  */
-
-  RINOK(PropVarEm_Alloc_Bstr(path, (unsigned)size - 1))
-  wchar_t *s = path->bstrVal;
   const Byte *p = ((const Byte *)NamesBuf + offset * 2);
-  // Utf16LE__To_WCHARs_Sep(p, size, s);
 
   for (size_t i = 0; i < size; i++)
   {
@@ -600,14 +518,10 @@ HRESULT CDatabase::GetPath_Prop(unsigned index, PROPVARIANT *path) const throw()
     #if WCHAR_PATH_SEPARATOR != L'/'
     if (c == L'/')
       c = WCHAR_PATH_SEPARATOR;
-    else if (c == L'\\')
-      c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
     #endif
     *s++ = c;
   }
 
-  // #endif
-
   return S_OK;
 
   /*
@@ -659,7 +573,7 @@ void CInArchive::WaitId(UInt64 id)
 {
   for (;;)
   {
-    const UInt64 type = ReadID();
+    UInt64 type = ReadID();
     if (type == id)
       return;
     if (type == NID::kEnd)
@@ -671,7 +585,7 @@ void CInArchive::WaitId(UInt64 id)
 
 void CInArchive::Read_UInt32_Vector(CUInt32DefVector &v)
 {
-  const unsigned numItems = v.Defs.Size();
+  unsigned numItems = v.Defs.Size();
   v.Vals.ClearAndSetSize(numItems);
   UInt32 *p = &v.Vals[0];
   const bool *defs = &v.Defs[0];
@@ -692,9 +606,12 @@ void CInArchive::ReadHashDigests(unsigned numItems, CUInt32DefVector &crcs)
 }
 
 
+#define k_Scan_NumCoders_MAX 64
+#define k_Scan_NumCodersStreams_in_Folder_MAX 64
+
 void CInArchive::ReadPackInfo(CFolders &f)
 {
-  const CNum numPackStreams = ReadNum();
+  CNum numPackStreams = ReadNum();
   
   WaitId(NID::kSize);
   f.PackPositions.Alloc(numPackStreams + 1);
@@ -703,7 +620,7 @@ void CInArchive::ReadPackInfo(CFolders &f)
   for (CNum i = 0; i < numPackStreams; i++)
   {
     f.PackPositions[i] = sum;
-    const UInt64 packSize = ReadNumber();
+    UInt64 packSize = ReadNumber();
     sum += packSize;
     if (sum < packSize)
       ThrowIncorrect();
@@ -731,7 +648,7 @@ void CInArchive::ReadUnpackInfo(
     CFolders &folders)
 {
   WaitId(NID::kFolder);
-  const CNum numFolders = ReadNum();
+  CNum numFolders = ReadNum();
 
   CNum numCodersOutStreams = 0;
   {
@@ -756,21 +673,21 @@ void CInArchive::ReadUnpackInfo(
     {
       UInt32 indexOfMainStream = 0;
       UInt32 numPackStreams = 0;
-      folders.FoCodersDataOffset[fo] = (size_t)(_inByteBack->GetPtr() - startBufPtr);
+      folders.FoCodersDataOffset[fo] = _inByteBack->GetPtr() - startBufPtr;
 
       CNum numInStreams = 0;
-      const CNum numCoders = inByte->ReadNum();
+      CNum numCoders = inByte->ReadNum();
     
       if (numCoders == 0 || numCoders > k_Scan_NumCoders_MAX)
         ThrowUnsupported();
 
       for (CNum ci = 0; ci < numCoders; ci++)
       {
-        const Byte mainByte = inByte->ReadByte();
+        Byte mainByte = inByte->ReadByte();
         if ((mainByte & 0xC0) != 0)
           ThrowUnsupported();
         
-        const unsigned idSize = (mainByte & 0xF);
+        unsigned idSize = (mainByte & 0xF);
         if (idSize > 8)
           ThrowUnsupported();
         if (idSize > inByte->GetRem())
@@ -799,18 +716,18 @@ void CInArchive::ReadUnpackInfo(
         
         if ((mainByte & 0x20) != 0)
         {
-          const CNum propsSize = inByte->ReadNum();
+          CNum propsSize = inByte->ReadNum();
           if (propsSize > inByte->GetRem())
             ThrowEndOfData();
           if (id == k_LZMA2 && propsSize == 1)
           {
-            const Byte v = *_inByteBack->GetPtr();
+            Byte v = *_inByteBack->GetPtr();
             if (folders.ParsedMethods.Lzma2Prop < v)
               folders.ParsedMethods.Lzma2Prop = v;
           }
           else if (id == k_LZMA && propsSize == 5)
           {
-            const UInt32 dicSize = GetUi32(_inByteBack->GetPtr() + 1);
+            UInt32 dicSize = GetUi32(_inByteBack->GetPtr() + 1);
             if (folders.ParsedMethods.LzmaDic < dicSize)
               folders.ParsedMethods.LzmaDic = dicSize;
           }
@@ -826,7 +743,7 @@ void CInArchive::ReadUnpackInfo(
       else
       {
         UInt32 i;
-        const CNum numBonds = numCoders - 1;
+        CNum numBonds = numCoders - 1;
         if (numInStreams < numBonds)
           ThrowUnsupported();
         
@@ -851,7 +768,7 @@ void CInArchive::ReadUnpackInfo(
         if (numPackStreams != 1)
           for (i = 0; i < numPackStreams; i++)
           {
-            const CNum index = inByte->ReadNum(); // PackStreams
+            CNum index = inByte->ReadNum(); // PackStreams
             if (index >= numInStreams || StreamUsed[index])
               ThrowUnsupported();
             StreamUsed[index] = true;
@@ -877,10 +794,10 @@ void CInArchive::ReadUnpackInfo(
       folders.FoToMainUnpackSizeIndex[fo] = (Byte)indexOfMainStream;
     }
     
-    const size_t dataSize = (size_t)(_inByteBack->GetPtr() - startBufPtr);
+    size_t dataSize = _inByteBack->GetPtr() - startBufPtr;
     folders.FoToCoderUnpackSizes[fo] = numCodersOutStreams;
     folders.FoStartPackStreamIndex[fo] = packStreamIndex;
-    folders.FoCodersDataOffset[fo] = (size_t)(_inByteBack->GetPtr() - startBufPtr);
+    folders.FoCodersDataOffset[fo] = _inByteBack->GetPtr() - startBufPtr;
     folders.CodersData.CopyFrom(startBufPtr, dataSize);
 
     // if (folders.NumPackStreams != packStreamIndex) ThrowUnsupported();
@@ -893,7 +810,7 @@ void CInArchive::ReadUnpackInfo(
 
   for (;;)
   {
-    const UInt64 type = ReadID();
+    UInt64 type = ReadID();
     if (type == NID::kEnd)
       return;
     if (type == NID::kCRC)
@@ -937,19 +854,19 @@ void CInArchive::ReadSubStreamsInfo(
     {
       // v3.13 incorrectly worked with empty folders
       // v4.07: we check that folder is empty
-      const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+      CNum numSubstreams = folders.NumUnpackStreamsVector[i];
       if (numSubstreams == 0)
         continue;
       UInt64 sum = 0;
       for (CNum j = 1; j < numSubstreams; j++)
       {
-        const UInt64 size = ReadNumber();
+        UInt64 size = ReadNumber();
         unpackSizes.Add(size);
         sum += size;
         if (sum < size)
           ThrowIncorrect();
       }
-      const UInt64 folderUnpackSize = folders.GetFolderUnpackSize(i);
+      UInt64 folderUnpackSize = folders.GetFolderUnpackSize(i);
       if (folderUnpackSize < sum)
         ThrowIncorrect();
       unpackSizes.Add(folderUnpackSize - sum);
@@ -962,7 +879,7 @@ void CInArchive::ReadSubStreamsInfo(
     {
       /* v9.26 - v9.29 incorrectly worked:
          if (folders.NumUnpackStreamsVector[i] == 0), it threw error */
-      const CNum val = folders.NumUnpackStreamsVector[i];
+      CNum val = folders.NumUnpackStreamsVector[i];
       if (val > 1)
         ThrowIncorrect();
       if (val == 1)
@@ -973,7 +890,7 @@ void CInArchive::ReadSubStreamsInfo(
   unsigned numDigests = 0;
   for (i = 0; i < folders.NumFolders; i++)
   {
-    const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+    CNum numSubstreams = folders.NumUnpackStreamsVector[i];
     if (numSubstreams != 1 || !folders.FolderCRCs.ValidAndDefined(i))
       numDigests += numSubstreams;
   }
@@ -996,7 +913,7 @@ void CInArchive::ReadSubStreamsInfo(
       
       for (i = 0; i < folders.NumFolders; i++)
       {
-        const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+        CNum numSubstreams = folders.NumUnpackStreamsVector[i];
         if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
         {
           digests.Defs[k] = true;
@@ -1028,7 +945,7 @@ void CInArchive::ReadSubStreamsInfo(
     unsigned k = 0;
     for (i = 0; i < folders.NumFolders; i++)
     {
-      const CNum numSubstreams = folders.NumUnpackStreamsVector[i];
+      CNum numSubstreams = folders.NumUnpackStreamsVector[i];
       if (numSubstreams == 1 && folders.FolderCRCs.ValidAndDefined(i))
       {
         digests.Defs[k] = true;
@@ -1045,8 +962,6 @@ void CInArchive::ReadSubStreamsInfo(
   }
 }
 
-
-
 void CInArchive::ReadStreamsInfo(
     const CObjectVector<CByteBuffer> *dataVector,
     UInt64 &dataOffset,
@@ -1059,11 +974,7 @@ void CInArchive::ReadStreamsInfo(
   if (type == NID::kPackInfo)
   {
     dataOffset = ReadNumber();
-    if (dataOffset > _rangeLimit)
-      ThrowIncorrect();
     ReadPackInfo(folders);
-    if (folders.PackPositions[folders.NumPackStreams] > _rangeLimit - dataOffset)
-      ThrowIncorrect();
     type = ReadID();
   }
 
@@ -1118,13 +1029,13 @@ void CInArchive::ReadBoolVector(unsigned numItems, CBoolVector &v)
       mask = 0x80;
     }
     p[i] = ((b & mask) != 0);
-    mask = (Byte)(mask >> 1);
+    mask >>= 1;
   }
 }
 
 void CInArchive::ReadBoolVector2(unsigned numItems, CBoolVector &v)
 {
-  const Byte allAreDefined = ReadByte();
+  Byte allAreDefined = ReadByte();
   if (allAreDefined == 0)
   {
     ReadBoolVector(numItems, v);
@@ -1161,7 +1072,7 @@ HRESULT CInArchive::ReadAndDecodePackedStreams(
     DECL_EXTERNAL_CODECS_LOC_VARS
     UInt64 baseOffset,
     UInt64 &dataOffset, CObjectVector<CByteBuffer> &dataVector
-    Z7_7Z_DECODER_CRYPRO_VARS_DECL
+    _7Z_DECODER_CRYPRO_VARS_DECL
     )
 {
   CFolders folders;
@@ -1179,13 +1090,14 @@ HRESULT CInArchive::ReadAndDecodePackedStreams(
   for (CNum i = 0; i < folders.NumFolders; i++)
   {
     CByteBuffer &data = dataVector.AddNew();
-    const UInt64 unpackSize64 = folders.GetFolderUnpackSize(i);
-    const size_t unpackSize = (size_t)unpackSize64;
+    UInt64 unpackSize64 = folders.GetFolderUnpackSize(i);
+    size_t unpackSize = (size_t)unpackSize64;
     if (unpackSize != unpackSize64)
       ThrowUnsupported();
     data.Alloc(unpackSize);
     
-    CMyComPtr2_Create<ISequentialOutStream, CBufPtrSeqOutStream> outStreamSpec;
+    CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
+    CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
     outStreamSpec->Init(data, unpackSize);
     
     bool dataAfterEnd_Error = false;
@@ -1194,30 +1106,27 @@ HRESULT CInArchive::ReadAndDecodePackedStreams(
         EXTERNAL_CODECS_LOC_VARS
         _stream, baseOffset + dataOffset,
         folders, i,
-        NULL, // &unpackSize64
+        NULL, // *unpackSize
         
-        outStreamSpec,
+        outStream,
         NULL, // *compressProgress
 
         NULL  // **inStreamMainRes
         , dataAfterEnd_Error
         
-        Z7_7Z_DECODER_CRYPRO_VARS
-        #if !defined(Z7_ST)
+        _7Z_DECODER_CRYPRO_VARS
+        #if !defined(_7ZIP_ST)
           , false // mtMode
           , 1     // numThreads
           , 0     // memUsage
         #endif
       );
     
-    RINOK(result)
+    RINOK(result);
     
     if (dataAfterEnd_Error)
       ThereIsHeaderError = true;
     
-    if (unpackSize != outStreamSpec->GetPos())
-      ThrowIncorrect();
-
     if (folders.FolderCRCs.ValidAndDefined(i))
       if (CrcCalc(data, unpackSize) != folders.FolderCRCs.Vals[i])
         ThrowIncorrect();
@@ -1232,7 +1141,7 @@ HRESULT CInArchive::ReadAndDecodePackedStreams(
 HRESULT CInArchive::ReadHeader(
     DECL_EXTERNAL_CODECS_LOC_VARS
     CDbEx &db
-    Z7_7Z_DECODER_CRYPRO_VARS_DECL
+    _7Z_DECODER_CRYPRO_VARS_DECL
     )
 {
   UInt64 type = ReadID();
@@ -1247,14 +1156,14 @@ HRESULT CInArchive::ReadHeader(
   
   if (type == NID::kAdditionalStreamsInfo)
   {
-    const HRESULT result = ReadAndDecodePackedStreams(
+    HRESULT result = ReadAndDecodePackedStreams(
         EXTERNAL_CODECS_LOC_VARS
         db.ArcInfo.StartPositionAfterHeader,
         db.ArcInfo.DataStartPosition2,
         dataVector
-        Z7_7Z_DECODER_CRYPRO_VARS
+        _7Z_DECODER_CRYPRO_VARS
         );
-    RINOK(result)
+    RINOK(result);
     db.ArcInfo.DataStartPosition2 += db.ArcInfo.StartPositionAfterHeader;
     type = ReadID();
   }
@@ -1287,14 +1196,14 @@ HRESULT CInArchive::ReadHeader(
   CBoolVector emptyStreamVector;
   CBoolVector emptyFileVector;
   CBoolVector antiFileVector;
-  unsigned numEmptyStreams = 0;
+  CNum numEmptyStreams = 0;
 
   for (;;)
   {
     const UInt64 type2 = ReadID();
     if (type2 == NID::kEnd)
       break;
-    const UInt64 size = ReadNumber();
+    UInt64 size = ReadNumber();
     if (size > _inByteBack->GetRem())
       ThrowIncorrect();
     CStreamSwitch switchProp;
@@ -1309,7 +1218,7 @@ HRESULT CInArchive::ReadHeader(
       {
         CStreamSwitch streamSwitch;
         streamSwitch.Set(this, &dataVector);
-        const size_t rem = _inByteBack->GetRem();
+        size_t rem = _inByteBack->GetRem();
         db.NamesBuf.Alloc(rem);
         ReadBytes(db.NamesBuf, rem);
         db.NameOffsets.Alloc(numFiles + 1);
@@ -1317,8 +1226,8 @@ HRESULT CInArchive::ReadHeader(
         unsigned i;
         for (i = 0; i < numFiles; i++)
         {
-          const size_t curRem = (rem - pos) / 2;
-          const UInt16 *buf = (const UInt16 *)(const void *)(db.NamesBuf.ConstData() + pos);
+          size_t curRem = (rem - pos) / 2;
+          const UInt16 *buf = (const UInt16 *)(db.NamesBuf + pos);
           size_t j;
           for (j = 0; j < curRem && buf[j] != 0; j++);
           if (j == curRem)
@@ -1464,7 +1373,7 @@ HRESULT CInArchive::ReadHeader(
   CNum emptyFileIndex = 0;
   CNum sizeIndex = 0;
 
-  const unsigned numAntiItems = BoolVector_CountSum(antiFileVector);
+  const CNum numAntiItems = BoolVector_CountSum(antiFileVector);
 
   if (numAntiItems != 0)
     db.IsAnti.ClearAndSetSize(numFiles);
@@ -1525,7 +1434,7 @@ void CDbEx::FillLinks()
 
   for (i = 0; i < Files.Size(); i++)
   {
-    const bool emptyStream = !Files[i].HasStream;
+    bool emptyStream = !Files[i].HasStream;
     if (indexInFolder == 0)
     {
       if (emptyStream)
@@ -1582,7 +1491,7 @@ void CDbEx::FillLinks()
 HRESULT CInArchive::ReadDatabase2(
     DECL_EXTERNAL_CODECS_LOC_VARS
     CDbEx &db
-    Z7_7Z_DECODER_CRYPRO_VARS_DECL
+    _7Z_DECODER_CRYPRO_VARS_DECL
     )
 {
   db.Clear();
@@ -1602,22 +1511,22 @@ HRESULT CInArchive::ReadDatabase2(
   UInt32 nextHeaderCRC = Get32(_header + 28);
 
   #ifdef FORMAT_7Z_RECOVERY
-  const UInt32 crcFromArc = Get32(_header + 8);
+  UInt32 crcFromArc = Get32(_header + 8);
   if (crcFromArc == 0 && nextHeaderOffset == 0 && nextHeaderSize == 0 && nextHeaderCRC == 0)
   {
     UInt64 cur, fileSize;
-    RINOK(InStream_GetPos(_stream, cur))
+    RINOK(_stream->Seek(0, STREAM_SEEK_CUR, &cur));
     const unsigned kCheckSize = 512;
     Byte buf[kCheckSize];
-    RINOK(InStream_GetSize_SeekToEnd(_stream, fileSize))
-    const UInt64 rem = fileSize - cur;
+    RINOK(_stream->Seek(0, STREAM_SEEK_END, &fileSize));
+    UInt64 rem = fileSize - cur;
     unsigned checkSize = kCheckSize;
     if (rem < kCheckSize)
       checkSize = (unsigned)(rem);
     if (checkSize < 3)
       return S_FALSE;
-    RINOK(InStream_SeekSet(_stream, fileSize - checkSize))
-    RINOK(ReadStream_FALSE(_stream, buf, (size_t)checkSize))
+    RINOK(_stream->Seek(fileSize - checkSize, STREAM_SEEK_SET, NULL));
+    RINOK(ReadStream_FALSE(_stream, buf, (size_t)checkSize));
 
     if (buf[checkSize - 1] != 0)
       return S_FALSE;
@@ -1625,8 +1534,8 @@ HRESULT CInArchive::ReadDatabase2(
     unsigned i;
     for (i = checkSize - 2;; i--)
     {
-      if ((buf[i] == NID::kEncodedHeader && buf[i + 1] == NID::kPackInfo) ||
-          (buf[i] == NID::kHeader        && buf[i + 1] == NID::kMainStreamsInfo))
+      if (buf[i] == NID::kEncodedHeader && buf[i + 1] == NID::kPackInfo ||
+          buf[i] == NID::kHeader && buf[i + 1] == NID::kMainStreamsInfo)
         break;
       if (i == 0)
         return S_FALSE;
@@ -1634,7 +1543,7 @@ HRESULT CInArchive::ReadDatabase2(
     nextHeaderSize = checkSize - i;
     nextHeaderOffset = rem - nextHeaderSize;
     nextHeaderCRC = CrcCalc(buf + i, (size_t)nextHeaderSize);
-    RINOK(InStream_SeekSet(_stream, cur))
+    RINOK(_stream->Seek(cur, STREAM_SEEK_SET, NULL));
     db.StartHeaderWasRecovered = true;
   }
   else
@@ -1651,39 +1560,32 @@ HRESULT CInArchive::ReadDatabase2(
   if ((Int64)nextHeaderOffset < 0 ||
       nextHeaderSize > ((UInt64)1 << 62))
     return S_FALSE;
-
-  HeadersSize = kHeaderSize;
-
   if (nextHeaderSize == 0)
   {
-    if (nextHeaderOffset != 0 || nextHeaderCRC != 0)
+    if (nextHeaderOffset != 0)
       return S_FALSE;
     db.IsArc = true;
-    db.HeadersSize = HeadersSize;
     return S_OK;
   }
   
   if (!db.StartHeaderWasRecovered)
     db.IsArc = true;
   
-  HeadersSize += nextHeaderSize;
-  // db.EndHeaderOffset = nextHeaderOffset;
-  _rangeLimit = nextHeaderOffset;
-
+  HeadersSize += kHeaderSize + nextHeaderSize;
   db.PhySize = kHeaderSize + nextHeaderOffset + nextHeaderSize;
   if (_fileEndPosition - db.ArcInfo.StartPositionAfterHeader < nextHeaderOffset + nextHeaderSize)
   {
     db.UnexpectedEnd = true;
     return S_FALSE;
   }
-  RINOK(_stream->Seek((Int64)nextHeaderOffset, STREAM_SEEK_CUR, NULL))
+  RINOK(_stream->Seek(nextHeaderOffset, STREAM_SEEK_CUR, NULL));
 
-  const size_t nextHeaderSize_t = (size_t)nextHeaderSize;
+  size_t nextHeaderSize_t = (size_t)nextHeaderSize;
   if (nextHeaderSize_t != nextHeaderSize)
     return E_OUTOFMEMORY;
   CByteBuffer buffer2(nextHeaderSize_t);
 
-  RINOK(ReadStream_FALSE(_stream, buffer2, nextHeaderSize_t))
+  RINOK(ReadStream_FALSE(_stream, buffer2, nextHeaderSize_t));
 
   if (CrcCalc(buffer2, nextHeaderSize_t) != nextHeaderCRC)
     ThrowIncorrect();
@@ -1696,19 +1598,19 @@ HRESULT CInArchive::ReadDatabase2(
   
   CObjectVector<CByteBuffer> dataVector;
   
-  const UInt64 type = ReadID();
+  UInt64 type = ReadID();
   if (type != NID::kHeader)
   {
     if (type != NID::kEncodedHeader)
       ThrowIncorrect();
-    const HRESULT result = ReadAndDecodePackedStreams(
+    HRESULT result = ReadAndDecodePackedStreams(
         EXTERNAL_CODECS_LOC_VARS
         db.ArcInfo.StartPositionAfterHeader,
         db.ArcInfo.DataStartPosition2,
         dataVector
-        Z7_7Z_DECODER_CRYPRO_VARS
+        _7Z_DECODER_CRYPRO_VARS
         );
-    RINOK(result)
+    RINOK(result);
     if (dataVector.Size() == 0)
       return S_OK;
     if (dataVector.Size() > 1)
@@ -1726,7 +1628,7 @@ HRESULT CInArchive::ReadDatabase2(
   return ReadHeader(
     EXTERNAL_CODECS_LOC_VARS
     db
-    Z7_7Z_DECODER_CRYPRO_VARS
+    _7Z_DECODER_CRYPRO_VARS
     );
 }
 
@@ -1734,14 +1636,14 @@ HRESULT CInArchive::ReadDatabase2(
 HRESULT CInArchive::ReadDatabase(
     DECL_EXTERNAL_CODECS_LOC_VARS
     CDbEx &db
-    Z7_7Z_DECODER_CRYPRO_VARS_DECL
+    _7Z_DECODER_CRYPRO_VARS_DECL
     )
 {
   try
   {
-    const HRESULT res = ReadDatabase2(
+    HRESULT res = ReadDatabase2(
       EXTERNAL_CODECS_LOC_VARS db
-      Z7_7Z_DECODER_CRYPRO_VARS
+      _7Z_DECODER_CRYPRO_VARS
       );
     if (ThereIsHeaderError)
       db.ThereIsHeaderError = true;