18.05

2025-12-08 20:06:58 -06:00 · 2018-05-02 22:28:04 +01:00
parent f19b649c73
commit 18dc2b4161
121 changed files with 3523 additions and 1866 deletions
--- a/CPP/7zip/Compress/Lzma2Encoder.cpp
+++ b/CPP/7zip/Compress/Lzma2Encoder.cpp
@@ -22,7 +22,7 @@ namespace NLzma2 {
 CEncoder::CEncoder()
 {
  _encoder = NULL;
-  _encoder = Lzma2Enc_Create(&g_Alloc, &g_BigAlloc);
+  _encoder = Lzma2Enc_Create(&g_AlignedAlloc, &g_BigAlloc);
  if (!_encoder)
    throw 1;
 }
--- a/CPP/7zip/Compress/LzmaEncoder.cpp
+++ b/CPP/7zip/Compress/LzmaEncoder.cpp
@@ -15,7 +15,7 @@ namespace NLzma {
 CEncoder::CEncoder()
 {
  _encoder = NULL;
-  _encoder = LzmaEnc_Create(&g_Alloc);
+  _encoder = LzmaEnc_Create(&g_AlignedAlloc);
  if (!_encoder)
    throw 1;
 }
@@ -23,7 +23,7 @@ CEncoder::CEncoder()
 CEncoder::~CEncoder()
 {
  if (_encoder)
-    LzmaEnc_Destroy(_encoder, &g_Alloc, &g_BigAlloc);
+    LzmaEnc_Destroy(_encoder, &g_AlignedAlloc, &g_BigAlloc);
 }

 static inline wchar_t GetUpperChar(wchar_t c)
@@ -168,7 +168,7 @@ STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream
  progressWrap.Init(progress);

  SRes res = LzmaEnc_Encode(_encoder, &outWrap.vt, &inWrap.vt,
-      progress ? &progressWrap.vt : NULL, &g_Alloc, &g_BigAlloc);
+      progress ? &progressWrap.vt : NULL, &g_AlignedAlloc, &g_BigAlloc);

  _inputProcessed = inWrap.Processed;

--- a/CPP/7zip/Compress/Rar1Decoder.cpp
+++ b/CPP/7zip/Compress/Rar1Decoder.cpp
@@ -9,77 +9,85 @@
 namespace NCompress {
 namespace NRar1 {

-static const UInt32 PosL1[] = {0,0,0,2,3,5,7,11,16,20,24,32,32, 256};
-static const UInt32 PosL2[] = {0,0,0,0,5,7,9,13,18,22,26,34,36, 256};
-static const UInt32 PosHf0[] = {0,0,0,0,0,8,16,24,33,33,33,33,33, 257};
-static const UInt32 PosHf1[] = {0,0,0,0,0,0,4,44,60,76,80,80,127, 257};
-static const UInt32 PosHf2[] = {0,0,0,0,0,0,2,7,53,117,233, 257,0};
-static const UInt32 PosHf3[] = {0,0,0,0,0,0,0,2,16,218,251, 257,0};
-static const UInt32 PosHf4[] = {0,0,0,0,0,0,0,0,0,255, 257,0,0};
+static const unsigned kNumBits = 12;
+
+static const Byte kShortLen1[16 * 3] =
+{
+  0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0xc0,0x80,0x90,0x98,0x9c,0xb0,0,
+  1,3,4,4,5,6,7,8,8,4,4,5,6,6,0,0,
+  1,4,4,4,5,6,7,8,8,4,4,5,6,6,4,0
+};
+
+static const Byte kShortLen2[16 * 3] =
+{
+  0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xc0,0x80,0x90,0x98,0x9c,0xb0,0,
+  2,3,3,3,4,4,5,6,6,4,4,5,6,6,0,0,
+  2,3,3,4,4,4,5,6,6,4,4,5,6,6,4,0
+};
+
+static const Byte PosL1[kNumBits + 1]  = { 0,0,2,1,2,2,4,5,4,4,8,0,224 };
+static const Byte PosL2[kNumBits + 1]  = { 0,0,0,5,2,2,4,5,4,4,8,2,220 };
+
+static const Byte PosHf0[kNumBits + 1] = { 0,0,0,0,8,8,8,9,0,0,0,0,224 };
+static const Byte PosHf1[kNumBits + 1] = { 0,0,0,0,0,4,40,16,16,4,0,47,130 };
+static const Byte PosHf2[kNumBits + 1] = { 0,0,0,0,0,2,5,46,64,116,24,0,0 };
+static const Byte PosHf3[kNumBits + 1] = { 0,0,0,0,0,0,2,14,202,33,6,0,0 };
+static const Byte PosHf4[kNumBits + 1] = { 0,0,0,0,0,0,0,0,255,2,0,0,0 };

 static const UInt32 kHistorySize = (1 << 16);

-/*
-class CCoderReleaser
-{
-  CDecoder *m_Coder;
-public:
-  CCoderReleaser(CDecoder *coder): m_Coder(coder) {}
-  ~CCoderReleaser() { m_Coder->ReleaseStreams(); }
-};
-*/
+CDecoder::CDecoder():
+   _isSolid(false),
+   _solidAllowed(false)
+   { }

-CDecoder::CDecoder(): m_IsSolid(false), _errorMode(false) { }
-
-void CDecoder::InitStructures()
-{
-  for (int i = 0; i < kNumRepDists; i++)
-    m_RepDists[i] = 0;
-  m_RepDistPtr = 0;
-  LastLength = 0;
-  LastDist = 0;
-}
-
-UInt32 CDecoder::ReadBits(int numBits) { return m_InBitStream.ReadBits(numBits); }
+UInt32 CDecoder::ReadBits(unsigned numBits) { return m_InBitStream.ReadBits(numBits); }

 HRESULT CDecoder::CopyBlock(UInt32 distance, UInt32 len)
 {
  if (len == 0)
    return S_FALSE;
+  if (m_UnpackSize < len)
+    return S_FALSE;
  m_UnpackSize -= len;
  return m_OutWindowStream.CopyBlock(distance, len) ? S_OK : S_FALSE;
 }


-UInt32 CDecoder::DecodeNum(const UInt32 *posTab)
+UInt32 CDecoder::DecodeNum(const Byte *numTab)
 {
-  UInt32 startPos = 2;
-  UInt32 num = m_InBitStream.GetValue(12);
+  /*
+  {
+    // we can check that tables are correct
+    UInt32 sum = 0;
+    for (unsigned i = 0; i <= kNumBits; i++)
+      sum += ((UInt32)numTab[i] << (kNumBits - i));
+    if (sum != (1 << kNumBits))
+      throw 111;
+  }
+  */
+
+  UInt32 val = m_InBitStream.GetValue(kNumBits);
+  UInt32 sum = 0;
+  unsigned i = 2;
+
  for (;;)
  {
-    UInt32 cur = (posTab[(size_t)startPos + 1] - posTab[startPos]) << (12 - startPos);
-    if (num < cur)
+    UInt32 num = numTab[i];
+    UInt32 cur = num << (kNumBits - i);
+    if (val < cur)
      break;
-    startPos++;
-    num -= cur;
+    i++;
+    val -= cur;
+    sum += num;
  }
-  m_InBitStream.MovePos(startPos);
-  return((num >> (12 - startPos)) + posTab[startPos]);
+  m_InBitStream.MovePos(i);
+  return ((val >> (kNumBits - i)) + sum);
 }

-static const Byte kShortLen1 [] = {1,3,4,4,5,6,7,8,8,4,4,5,6,6 };
-static const Byte kShortLen1a[] = {1,4,4,4,5,6,7,8,8,4,4,5,6,6,4 };
-static const Byte kShortLen2 [] = {2,3,3,3,4,4,5,6,6,4,4,5,6,6 };
-static const Byte kShortLen2a[] = {2,3,3,4,4,4,5,6,6,4,4,5,6,6,4 };
-static const UInt32 kShortXor1[] = {0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff,0xc0,0x80,0x90,0x98,0x9c,0xb0};
-static const UInt32 kShortXor2[] = {0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xc0,0x80,0x90,0x98,0x9c,0xb0};

 HRESULT CDecoder::ShortLZ()
 {
-  UInt32 len, saveLen, dist;
-  int distancePlace;
-  const Byte *kShortLen;
-  const UInt32 *kShortXor;
  NumHuf = 0;

  if (LCount == 2)
@@ -91,20 +99,14 @@ HRESULT CDecoder::ShortLZ()

  UInt32 bitField = m_InBitStream.GetValue(8);

-  if (AvrLn1 < 37)
+  UInt32 len, dist;
  {
-    kShortLen = Buf60 ? kShortLen1a : kShortLen1;
-    kShortXor = kShortXor1;
+    const Byte *xors = (AvrLn1 < 37) ? kShortLen1 : kShortLen2;
+    const Byte *lens = xors + 16 + Buf60;
+    for (len = 0; ((bitField ^ xors[len]) >> (8 - lens[len])) != 0; len++);
+    m_InBitStream.MovePos(lens[len]);
  }
-  else
-  {
-    kShortLen = Buf60 ? kShortLen2a : kShortLen2;
-    kShortXor = kShortXor2;
-  }
-
-  for (len = 0; ((bitField ^ kShortXor[len]) & (~(0xff >> kShortLen[len]))) != 0; len++);
-  m_InBitStream.MovePos(kShortLen[len]);
-
+  
  if (len >= 9)
  {
    if (len == 9)
@@ -112,9 +114,11 @@ HRESULT CDecoder::ShortLZ()
      LCount++;
      return CopyBlock(LastDist, LastLength);
    }
+
+    LCount = 0;
+
    if (len == 14)
    {
-      LCount = 0;
      len = DecodeNum(PosL2) + 5;
      dist = 0x8000 + ReadBits(15) - 1;
      LastLength = len;
@@ -122,19 +126,22 @@ HRESULT CDecoder::ShortLZ()
      return CopyBlock(dist, len);
    }

-    LCount = 0;
-    saveLen = len;
+    UInt32 saveLen = len;
    dist = m_RepDists[(m_RepDistPtr - (len - 9)) & 3];
-    len = DecodeNum(PosL1) + 2;
-    if (len == 0x101 && saveLen == 10)
+    
+    len = DecodeNum(PosL1);
+    
+    if (len == 0xff && saveLen == 10)
    {
-      Buf60 ^= 1;
+      Buf60 ^= 16;
      return S_OK;
    }
    if (dist >= 256)
+    {
      len++;
-    if (dist >= MaxDist3 - 1)
-      len++;
+      if (dist >= MaxDist3 - 1)
+        len++;
+    }
  }
  else
  {
@@ -142,21 +149,23 @@ HRESULT CDecoder::ShortLZ()
    AvrLn1 += len;
    AvrLn1 -= AvrLn1 >> 4;
    
-    distancePlace = DecodeNum(PosHf2) & 0xff;
-    dist = ChSetA[(unsigned)distancePlace];
-    if (--distancePlace != -1)
+    unsigned distancePlace = DecodeNum(PosHf2) & 0xff;
+    
+    dist = ChSetA[distancePlace];
+    
+    if (distancePlace != 0)
    {
      PlaceA[dist]--;
-      UInt32 lastDistance = ChSetA[(unsigned)distancePlace];
+      UInt32 lastDistance = ChSetA[(size_t)distancePlace - 1];
      PlaceA[lastDistance]++;
-      ChSetA[(size_t)(unsigned)distancePlace + 1] = lastDistance;
-      ChSetA[(unsigned)distancePlace] = dist;
+      ChSetA[distancePlace] = lastDistance;
+      ChSetA[(size_t)distancePlace - 1] = dist;
    }
-    len += 2;
  }

  m_RepDists[m_RepDistPtr++] = dist;
  m_RepDistPtr &= 3;
+  len += 2;
  LastLength = len;
  LastDist = dist;
  return CopyBlock(dist, len);
@@ -177,12 +186,10 @@ HRESULT CDecoder::LongLZ()
    Nlzb = 0x90;
    Nhfb >>= 1;
  }
-  oldAvr2=AvrLn2;
+  oldAvr2 = AvrLn2;

-  if (AvrLn2 >= 122)
-    len = DecodeNum(PosL2);
-  else if (AvrLn2 >= 64)
-    len = DecodeNum(PosL1);
+  if (AvrLn2 >= 64)
+    len = DecodeNum(AvrLn2 < 122 ? PosL1 : PosL2);
  else
  {
    UInt32 bitField = m_InBitStream.GetValue(16);
@@ -193,8 +200,8 @@ HRESULT CDecoder::LongLZ()
    }
    else
    {
-      for (len = 0; ((bitField << len) & 0x8000) == 0; len++)
-        ;
+      for (len = 0; ((bitField << len) & 0x8000) == 0; len++);
+      
      m_InBitStream.MovePos(len + 1);
    }
  }
@@ -202,24 +209,26 @@ HRESULT CDecoder::LongLZ()
  AvrLn2 += len;
  AvrLn2 -= AvrLn2 >> 5;

-  if (AvrPlcB > 0x28ff)
-    distancePlace = DecodeNum(PosHf2);
-  else if (AvrPlcB > 0x6ff)
-    distancePlace = DecodeNum(PosHf1);
-  else
-    distancePlace = DecodeNum(PosHf0);
+  {
+    const Byte *tab;
+         if (AvrPlcB >= 0x2900) tab = PosHf2;
+    else if (AvrPlcB >= 0x0700) tab = PosHf1;
+    else                        tab = PosHf0;
+    distancePlace = DecodeNum(tab); // [0, 256]
+  }

  AvrPlcB += distancePlace;
  AvrPlcB -= AvrPlcB >> 8;
+
+  distancePlace &= 0xff;
  
  for (;;)
  {
-    dist = ChSetB[distancePlace & 0xff];
+    dist = ChSetB[distancePlace];
    newDistancePlace = NToPlB[dist++ & 0xff]++;
-    if (!(dist & 0xff))
-      CorrHuff(ChSetB,NToPlB);
-    else
+    if (dist & 0xff)
      break;
+    CorrHuff(ChSetB,NToPlB);
  }

  ChSetB[distancePlace] = ChSetB[newDistancePlace];
@@ -235,9 +244,8 @@ HRESULT CDecoder::LongLZ()
      AvrLn3++;
      AvrLn3 -= AvrLn3 >> 8;
    }
-    else
-      if (AvrLn3 > 0)
-        AvrLn3--;
+    else if (AvrLn3 > 0)
+      AvrLn3--;
  
  len += 3;
  
@@ -265,57 +273,62 @@ HRESULT CDecoder::HuffDecode()
  UInt32 curByte, newBytePlace;
  UInt32 len;
  UInt32 dist;
-  int bytePlace;
-
-  if      (AvrPlc > 0x75ff)  bytePlace = DecodeNum(PosHf4);
-  else if (AvrPlc > 0x5dff)  bytePlace = DecodeNum(PosHf3);
-  else if (AvrPlc > 0x35ff)  bytePlace = DecodeNum(PosHf2);
-  else if (AvrPlc > 0x0dff)  bytePlace = DecodeNum(PosHf1);
-  else                       bytePlace = DecodeNum(PosHf0);
+  unsigned bytePlace;
+  {
+    const Byte *tab;
+    
+    if      (AvrPlc >= 0x7600)  tab = PosHf4;
+    else if (AvrPlc >= 0x5e00)  tab = PosHf3;
+    else if (AvrPlc >= 0x3600)  tab = PosHf2;
+    else if (AvrPlc >= 0x0e00)  tab = PosHf1;
+    else                        tab = PosHf0;
+    
+    bytePlace = DecodeNum(tab); // [0, 256]
+  }
  
  if (StMode)
  {
-    if (--bytePlace == -1)
+    if (bytePlace == 0)
    {
      if (ReadBits(1))
      {
-        NumHuf = StMode = 0;
+        NumHuf = 0;
+        StMode = false;
        return S_OK;
      }
-      else
-      {
-        len = (ReadBits(1)) ? 4 : 3;
-        dist = DecodeNum(PosHf2);
-        dist = (dist << 5) | ReadBits(5);
-        return CopyBlock(dist - 1, len);
-      }
+      len = ReadBits(1) + 3;
+      dist = DecodeNum(PosHf2);
+      dist = (dist << 5) | ReadBits(5);
+      if (dist == 0)
+        return S_FALSE;
+      return CopyBlock(dist - 1, len);
    }
+    bytePlace--; // bytePlace is [0, 255]
  }
  else if (NumHuf++ >= 16 && FlagsCnt == 0)
-    StMode = 1;
+    StMode = true;
  
  bytePlace &= 0xff;
  AvrPlc += bytePlace;
  AvrPlc -= AvrPlc >> 8;
-  Nhfb+=16;
+  Nhfb += 16;
  
  if (Nhfb > 0xff)
  {
-    Nhfb=0x90;
+    Nhfb = 0x90;
    Nlzb >>= 1;
  }

-  m_UnpackSize --;
+  m_UnpackSize--;
  m_OutWindowStream.PutByte((Byte)(ChSet[bytePlace] >> 8));

  for (;;)
  {
    curByte = ChSet[bytePlace];
    newBytePlace = NToPl[curByte++ & 0xff]++;
-    if ((curByte & 0xff) > 0xa1)
-      CorrHuff(ChSet, NToPl);
-    else
+    if ((curByte & 0xff) <= 0xa1)
      break;
+    CorrHuff(ChSet, NToPl);
  }

  ChSet[bytePlace] = ChSet[newBytePlace];
@@ -327,7 +340,10 @@ HRESULT CDecoder::HuffDecode()
 void CDecoder::GetFlagsBuf()
 {
  UInt32 flags, newFlagsPlace;
-  UInt32 flagsPlace = DecodeNum(PosHf2);
+  UInt32 flagsPlace = DecodeNum(PosHf2); // [0, 256]
+
+  if (flagsPlace >= ARRAY_SIZE(ChSetC))
+    return;

  for (;;)
  {
@@ -343,20 +359,6 @@ void CDecoder::GetFlagsBuf()
  ChSetC[newFlagsPlace] = flags;
 }

-void CDecoder::InitData()
-{
-  if (!m_IsSolid)
-  {
-    AvrPlcB = AvrLn1 = AvrLn2 = AvrLn3 = NumHuf = Buf60 = 0;
-    AvrPlc = 0x3500;
-    MaxDist3 = 0x2001;
-    Nhfb = Nlzb = 0x80;
-  }
-  FlagsCnt = 0;
-  FlagBuf = 0;
-  StMode = 0;
-  LCount = 0;
-}

 void CDecoder::CorrHuff(UInt32 *CharSet,UInt32 *NumToPlace)
 {
@@ -369,129 +371,145 @@ void CDecoder::CorrHuff(UInt32 *CharSet,UInt32 *NumToPlace)
    NumToPlace[i] = (7 - i) * 32;
 }

-void CDecoder::InitHuff()
-{
-  for (UInt32 i = 0; i < 256; i++)
-  {
-    Place[i] = PlaceA[i] = PlaceB[i] = i;
-    PlaceC[i] = (~i + 1) & 0xff;
-    ChSet[i] = ChSetB[i] = i << 8;
-    ChSetA[i] = i;
-    ChSetC[i] = ((~i + 1) & 0xff) << 8;
-  }
-  memset(NToPl, 0, sizeof(NToPl));
-  memset(NToPlB, 0, sizeof(NToPlB));
-  memset(NToPlC, 0, sizeof(NToPlC));
-  CorrHuff(ChSetB, NToPlB);
-}
+

 HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo * /* progress */)
 {
-  if (inSize == NULL || outSize == NULL)
+  if (!inSize || !outSize)
    return E_INVALIDARG;

+  if (_isSolid && !_solidAllowed)
+    return S_FALSE;
+
+  _solidAllowed = false;
+
  if (!m_OutWindowStream.Create(kHistorySize))
    return E_OUTOFMEMORY;
  if (!m_InBitStream.Create(1 << 20))
    return E_OUTOFMEMORY;

-  m_UnpackSize = (Int64)*outSize;
+  m_UnpackSize = *outSize;
+
  m_OutWindowStream.SetStream(outStream);
-  m_OutWindowStream.Init(m_IsSolid);
+  m_OutWindowStream.Init(_isSolid);
  m_InBitStream.SetStream(inStream);
  m_InBitStream.Init();

-  // CCoderReleaser coderReleaser(this);
-  InitData();
-  if (!m_IsSolid)
+  // InitData
+
+  FlagsCnt = 0;
+  FlagBuf = 0;
+  StMode = false;
+  LCount = 0;
+
+  if (!_isSolid)
  {
-    _errorMode = false;
-    InitStructures();
-    InitHuff();
-  }
-  
-  if (_errorMode)
-    return S_FALSE;
+    AvrPlcB = AvrLn1 = AvrLn2 = AvrLn3 = NumHuf = Buf60 = 0;
+    AvrPlc = 0x3500;
+    MaxDist3 = 0x2001;
+    Nhfb = Nlzb = 0x80;
+
+    {
+      // InitStructures
+      for (int i = 0; i < kNumRepDists; i++)
+        m_RepDists[i] = 0;
+      m_RepDistPtr = 0;
+      LastLength = 0;
+      LastDist = 0;
+    }
    
+    // InitHuff
+    
+    for (UInt32 i = 0; i < 256; i++)
+    {
+      Place[i] = PlaceA[i] = PlaceB[i] = i;
+      UInt32 c = (~i + 1) & 0xff;
+      PlaceC[i] = c;
+      ChSet[i] = ChSetB[i] = i << 8;
+      ChSetA[i] = i;
+      ChSetC[i] = c << 8;
+    }
+    memset(NToPl, 0, sizeof(NToPl));
+    memset(NToPlB, 0, sizeof(NToPlB));
+    memset(NToPlC, 0, sizeof(NToPlC));
+    CorrHuff(ChSetB, NToPlB);
+  }
+   
  if (m_UnpackSize > 0)
  {
    GetFlagsBuf();
    FlagsCnt = 8;
  }

-  while (m_UnpackSize > 0)
+  while (m_UnpackSize != 0)
  {
-    if (StMode)
+    if (!StMode)
    {
-      RINOK(HuffDecode());
-      continue;
-    }
-
-    if (--FlagsCnt < 0)
-    {
-      GetFlagsBuf();
-      FlagsCnt=7;
-    }
-
-    if (FlagBuf & 0x80)
-    {
-      FlagBuf <<= 1;
-      if (Nlzb > Nhfb)
-      {
-        RINOK(LongLZ());
-      }
-      else
-      {
-        RINOK(HuffDecode());
-      }
-    }
-    else
-    {
-      FlagBuf <<= 1;
      if (--FlagsCnt < 0)
      {
        GetFlagsBuf();
        FlagsCnt = 7;
      }
+      
      if (FlagBuf & 0x80)
      {
        FlagBuf <<= 1;
        if (Nlzb > Nhfb)
-        {
-          RINOK(HuffDecode());
-        }
-        else
        {
          RINOK(LongLZ());
+          continue;
        }
      }
      else
      {
        FlagBuf <<= 1;
-        RINOK(ShortLZ());
+        
+        if (--FlagsCnt < 0)
+        {
+          GetFlagsBuf();
+          FlagsCnt = 7;
+        }
+
+        if ((FlagBuf & 0x80) == 0)
+        {
+          FlagBuf <<= 1;
+          RINOK(ShortLZ());
+          continue;
+        }
+        
+        FlagBuf <<= 1;
+        
+        if (Nlzb <= Nhfb)
+        {
+          RINOK(LongLZ());
+          continue;
+        }
      }
    }
+
+    RINOK(HuffDecode());
  }
-  if (m_UnpackSize < 0)
-    return S_FALSE;
+  
+  _solidAllowed = true;
  return m_OutWindowStream.Flush();
 }

+
 STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
 {
  try { return CodeReal(inStream, outStream, inSize, outSize, progress); }
-  catch(const CInBufferException &e) { _errorMode = true; return e.ErrorCode; }
-  catch(const CLzOutWindowException &e) { _errorMode = true; return e.ErrorCode; }
-  catch(...) { _errorMode = true; return S_FALSE; }
+  catch(const CInBufferException &e) { return e.ErrorCode; }
+  catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+  catch(...) { return S_FALSE; }
 }

 STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
 {
  if (size < 1)
    return E_INVALIDARG;
-  m_IsSolid = ((data[0] & 1) != 0);
+  _isSolid = ((data[0] & 1) != 0);
  return S_OK;
 }

--- a/CPP/7zip/Compress/Rar1Decoder.h
+++ b/CPP/7zip/Compress/Rar1Decoder.h
@@ -20,49 +20,45 @@ namespace NRar1 {

 const UInt32 kNumRepDists = 4;

-typedef NBitm::CDecoder<CInBuffer> CBitDecoder;
-
 class CDecoder :
  public ICompressCoder,
  public ICompressSetDecoderProperties2,
  public CMyUnknownImp
 {
-public:
  CLzOutWindow m_OutWindowStream;
-  CBitDecoder m_InBitStream;
+  NBitm::CDecoder<CInBuffer> m_InBitStream;

-  UInt32 m_RepDists[kNumRepDists];
-  UInt32 m_RepDistPtr;
+  UInt64 m_UnpackSize;

  UInt32 LastDist;
  UInt32 LastLength;

-  Int64 m_UnpackSize;
-  bool m_IsSolid;
-  bool _errorMode;
+  UInt32 m_RepDistPtr;
+  UInt32 m_RepDists[kNumRepDists];

-  UInt32 ReadBits(int numBits);
+  bool _isSolid;
+  bool _solidAllowed;
+
+  bool StMode;
+  int FlagsCnt;
+  UInt32 FlagBuf, AvrPlc, AvrPlcB, AvrLn1, AvrLn2, AvrLn3;
+  unsigned Buf60, NumHuf, LCount;
+  UInt32 Nhfb, Nlzb, MaxDist3;
+
+  UInt32 ChSet[256], ChSetA[256], ChSetB[256], ChSetC[256];
+  UInt32 Place[256], PlaceA[256], PlaceB[256], PlaceC[256];
+  UInt32 NToPl[256], NToPlB[256], NToPlC[256];
+
+  UInt32 ReadBits(unsigned numBits);
  HRESULT CopyBlock(UInt32 distance, UInt32 len);
-
-  UInt32 DecodeNum(const UInt32 *posTab);
+  UInt32 DecodeNum(const Byte *numTab);
  HRESULT ShortLZ();
  HRESULT LongLZ();
  HRESULT HuffDecode();
  void GetFlagsBuf();
-  void InitData();
-  void InitHuff();
  void CorrHuff(UInt32 *CharSet, UInt32 *NumToPlace);
  void OldUnpWriteBuf();
  
-  UInt32 ChSet[256],ChSetA[256],ChSetB[256],ChSetC[256];
-  UInt32 Place[256],PlaceA[256],PlaceB[256],PlaceC[256];
-  UInt32 NToPl[256],NToPlB[256],NToPlC[256];
-  UInt32 FlagBuf,AvrPlc,AvrPlcB,AvrLn1,AvrLn2,AvrLn3;
-  int Buf60,NumHuf,StMode,LCount,FlagsCnt;
-  UInt32 Nhfb,Nlzb,MaxDist3;
-
-  void InitStructures();
-
  HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);

@@ -71,14 +67,6 @@ public:

  MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)

-  /*
-  void ReleaseStreams()
-  {
-    m_OutWindowStream.ReleaseStream();
-    m_InBitStream.ReleaseStream();
-  }
-  */
-
  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);

--- a/CPP/7zip/Compress/Rar2Decoder.cpp
+++ b/CPP/7zip/Compress/Rar2Decoder.cpp
@@ -80,7 +80,8 @@ static const UInt32 kHistorySize = 1 << 20;
 static const UInt32 kWindowReservSize = (1 << 22) + 256;

 CDecoder::CDecoder():
-  m_IsSolid(false),
+  _isSolid(false),
+  _solidAllowed(false),
  m_TablesOK(false)
 {
 }
@@ -227,18 +228,6 @@ bool CDecoder::ReadLastTables()
  return true;
 }

-/*
-class CCoderReleaser
-{
-  CDecoder *m_Coder;
-public:
-  CCoderReleaser(CDecoder *coder): m_Coder(coder) {}
-  ~CCoderReleaser()
-  {
-    m_Coder->ReleaseStreams();
-  }
-};
-*/

 bool CDecoder::DecodeMm(UInt32 pos)
 {
@@ -343,9 +332,13 @@ bool CDecoder::DecodeLz(Int32 pos)
 HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
 {
-  if (inSize == NULL || outSize == NULL)
+  if (!inSize || !outSize)
    return E_INVALIDARG;

+  if (_isSolid && !_solidAllowed)
+    return S_FALSE;
+  _solidAllowed = false;
+
  if (!m_OutWindowStream.Create(kHistorySize))
    return E_OUTOFMEMORY;
  if (!m_InBitStream.Create(1 << 20))
@@ -356,12 +349,12 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
  UInt64 pos = 0, unPackSize = *outSize;
  
  m_OutWindowStream.SetStream(outStream);
-  m_OutWindowStream.Init(m_IsSolid);
+  m_OutWindowStream.Init(_isSolid);
  m_InBitStream.SetStream(inStream);
  m_InBitStream.Init();

  // CCoderReleaser coderReleaser(this);
-  if (!m_IsSolid)
+  if (!_isSolid)
  {
    InitStructures();
    if (unPackSize == 0)
@@ -369,6 +362,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
      if (m_InBitStream.GetProcessedSize() + 2 <= m_PackSize) // test it: probably incorrect;
        if (!ReadTables())
          return S_FALSE;
+      _solidAllowed = true;
      return S_OK;
    }
    ReadTables();
@@ -415,6 +409,9 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *

  if (!ReadLastTables())
    return S_FALSE;
+
+  _solidAllowed = true;
+
  return m_OutWindowStream.Flush();
 }

@@ -431,7 +428,7 @@ STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
 {
  if (size < 1)
    return E_INVALIDARG;
-  m_IsSolid = ((data[0] & 1) != 0);
+  _isSolid = ((data[0] & 1) != 0);
  return S_OK;
 }

--- a/CPP/7zip/Compress/Rar2Decoder.h
+++ b/CPP/7zip/Compress/Rar2Decoder.h
@@ -125,7 +125,8 @@ class CDecoder :

  UInt32 m_LastLength;

-  bool m_IsSolid;
+  bool _isSolid;
+  bool _solidAllowed;
  bool m_TablesOK;
  bool m_AudioMode;

@@ -159,14 +160,6 @@ public:

  MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)

-  /*
-  void ReleaseStreams()
-  {
-    m_OutWindowStream.ReleaseStream();
-    m_InBitStream.ReleaseStream();
-  }
-  */
-
  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);

--- a/CPP/7zip/Compress/Rar3Decoder.cpp
+++ b/CPP/7zip/Compress/Rar3Decoder.cpp
@@ -94,8 +94,8 @@ CDecoder::CDecoder():
  _writtenFileSize(0),
  _vmData(0),
  _vmCode(0),
-  m_IsSolid(false),
-  _errorMode(false)
+  _isSolid(false),
+  _solidAllowed(false)
 {
  Ppmd7_Construct(&_ppmd);
 }
@@ -829,7 +829,7 @@ HRESULT CDecoder::CodeReal(ICompressProgressInfo *progress)
  _writtenFileSize = 0;
  _unsupportedFilter = false;
  
-  if (!m_IsSolid)
+  if (!_isSolid)
  {
    _lzSize = 0;
    _winPos = 0;
@@ -842,18 +842,23 @@ HRESULT CDecoder::CodeReal(ICompressProgressInfo *progress)
    PpmEscChar = 2;
    PpmError = true;
    InitFilters();
-    _errorMode = false;
+    // _errorMode = false;
  }

+  /*
  if (_errorMode)
    return S_FALSE;
+  */

-  if (!m_IsSolid || !TablesRead)
+  if (!_isSolid || !TablesRead)
  {
    bool keepDecompressing;
    RINOK(ReadTables(keepDecompressing));
    if (!keepDecompressing)
+    {
+      _solidAllowed = true;
      return S_OK;
+    }
  }

  for (;;)
@@ -878,6 +883,9 @@ HRESULT CDecoder::CodeReal(ICompressProgressInfo *progress)
    if (!keepDecompressing)
      break;
  }
+
+  _solidAllowed = true;
+
  RINOK(WriteBuf());
  UInt64 packSize = m_InBitStream.BitDecoder.GetProcessedSize();
  RINOK(progress->SetRatioInfo(&packSize, &_writtenFileSize));
@@ -898,6 +906,10 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
    if (!inSize)
      return E_INVALIDARG;

+    if (_isSolid && !_solidAllowed)
+      return S_FALSE;
+    _solidAllowed = false;
+
    if (!_vmData)
    {
      _vmData = (Byte *)::MidAlloc(kVmDataSizeMax + kVmCodeSizeMax);
@@ -926,8 +938,8 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
    _unpackSize = outSize ? *outSize : (UInt64)(Int64)-1;
    return CodeReal(progress);
  }
-  catch(const CInBufferException &e)  { _errorMode = true; return e.ErrorCode; }
-  catch(...) { _errorMode = true; return S_FALSE; }
+  catch(const CInBufferException &e)  { /* _errorMode = true; */ return e.ErrorCode; }
+  catch(...) { /* _errorMode = true; */ return S_FALSE; }
  // CNewException is possible here. But probably CNewException is caused
  // by error in data stream.
 }
@@ -936,7 +948,7 @@ STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
 {
  if (size < 1)
    return E_INVALIDARG;
-  m_IsSolid = ((data[0] & 1) != 0);
+  _isSolid = ((data[0] & 1) != 0);
  return S_OK;
 }

--- a/CPP/7zip/Compress/Rar3Decoder.h
+++ b/CPP/7zip/Compress/Rar3Decoder.h
@@ -191,8 +191,9 @@ class CDecoder:
  CRecordVector<CTempFilter *>  _tempFilters;
  UInt32 _lastFilter;

-  bool m_IsSolid;
-  bool _errorMode;
+  bool _isSolid;
+  bool _solidAllowed;
+  // bool _errorMode;

  bool _lzMode;
  bool _unsupportedFilter;
--- a/CPP/7zip/Compress/Rar5Decoder.cpp
+++ b/CPP/7zip/Compress/Rar5Decoder.cpp
@@ -72,6 +72,7 @@ CDecoder::CDecoder():
    _writtenFileSize(0),
    _dictSizeLog(0),
    _isSolid(false),
+    _solidAllowed(false),
    _wasInit(false),
    _inputBuf(NULL)
 {
@@ -334,58 +335,63 @@ HRESULT CDecoder::ReadTables(CBitDecoder &_bitStream)
 {
  if (_progress)
  {
-    UInt64 packSize = _bitStream.GetProcessedSize();
+    const UInt64 packSize = _bitStream.GetProcessedSize();
    RINOK(_progress->SetRatioInfo(&packSize, &_writtenFileSize));
  }

  _bitStream.AlignToByte();
  _bitStream.Prepare();
  
-  unsigned flags = _bitStream.ReadByteInAligned();
-  unsigned checkSum = _bitStream.ReadByteInAligned();
-  checkSum ^= flags;
-
-  UInt32 blockSize;
  {
+    unsigned flags = _bitStream.ReadByteInAligned();
+    unsigned checkSum = _bitStream.ReadByteInAligned();
+    checkSum ^= flags;
    unsigned num = (flags >> 3) & 3;
    if (num == 3)
      return S_FALSE;
-    blockSize = _bitStream.ReadByteInAligned();
-    if (num > 0)
+    UInt32 blockSize = _bitStream.ReadByteInAligned();
+    checkSum ^= blockSize;
+
+    if (num != 0)
    {
-      blockSize += (UInt32)_bitStream.ReadByteInAligned() << 8;
+      unsigned b = _bitStream.ReadByteInAligned();
+      checkSum ^= b;
+      blockSize += (UInt32)b << 8;
      if (num > 1)
-        blockSize += (UInt32)_bitStream.ReadByteInAligned() << 16;
+      {
+        b = _bitStream.ReadByteInAligned();
+        checkSum ^= b;
+        blockSize += (UInt32)b << 16;
+      }
    }
-  }
-
-  checkSum ^= blockSize ^ (blockSize >> 8) ^ (blockSize >> 16);
-  if ((Byte)checkSum != 0x5A)
-    return S_FALSE;
-
-  unsigned blockSizeBits7 = (flags & 7) + 1;
-
-  if (blockSize == 0 && blockSizeBits7 != 8)
-    return S_FALSE;
-
-  blockSize += (blockSizeBits7 >> 3);
-  blockSize--;
-
-  _bitStream._blockEndBits7 = (Byte)(blockSizeBits7 & 7);
-  _bitStream._blockEnd = _bitStream.GetProcessedSize_Round() + blockSize;
-
-  _bitStream.SetCheck2();
-
-  _isLastBlock = ((flags & 0x40) != 0);
-
-  if ((flags & 0x80) == 0)
-  {
-    if (!_tableWasFilled && blockSize != 0)
+    
+    if (checkSum != 0x5A)
      return S_FALSE;
-    return S_OK;
-  }

-  _tableWasFilled = false;
+    unsigned blockSizeBits7 = (flags & 7) + 1;
+    blockSize += (blockSizeBits7 >> 3);
+    if (blockSize == 0)
+      return S_FALSE;
+    blockSize--;
+    blockSizeBits7 &= 7;
+
+    _bitStream._blockEndBits7 = (Byte)blockSizeBits7;
+    _bitStream._blockEnd = _bitStream.GetProcessedSize_Round() + blockSize;
+    
+    _bitStream.SetCheck2();
+    
+    _isLastBlock = ((flags & 0x40) != 0);
+    
+    if ((flags & 0x80) == 0)
+    {
+      if (!_tableWasFilled)
+        if (blockSize != 0 || blockSizeBits7 != 0)
+          return S_FALSE;
+      return S_OK;
+    }
+    
+    _tableWasFilled = false;
+  }

  {
    Byte lens2[kLevelTableSize];
@@ -596,6 +602,10 @@ HRESULT CDecoder::DecodeLZ()
          }
        }
      }
+
+      // that check is not required, but it can help, if there is BUG in another code
+      if (!_tableWasFilled)
+        break; // return S_FALSE;
    }

    UInt32 sym = m_MainDecoder.Decode(&_bitStream);
@@ -797,7 +807,10 @@ HRESULT CDecoder::CodeReal()
  */

  if (res == S_OK)
+  {
+    _solidAllowed = true;
    res = res2;
+  }
     
  if (res == S_OK && _unpackSize_Defined && _writtenFileSize != _unpackSize)
    return S_FALSE;
@@ -817,6 +830,10 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
 {
  try
  {
+    if (_isSolid && !_solidAllowed)
+      return S_FALSE;
+    _solidAllowed = false;
+
    if (_dictSizeLog >= sizeof(size_t) * 8)
      return E_NOTIMPL;

--- a/CPP/7zip/Compress/Rar5Decoder.h
+++ b/CPP/7zip/Compress/Rar5Decoder.h
@@ -127,7 +127,7 @@ public:
    return *_buf++;
  }

-  UInt32 GetValue(unsigned numBits)
+  UInt32 GetValue(unsigned numBits) const
  {
    UInt32 v = ((UInt32)_buf[0] << 16) | ((UInt32)_buf[1] << 8) | (UInt32)_buf[2];
    v >>= (24 - numBits - _bitPos);
@@ -218,6 +218,13 @@ class CDecoder:
  bool _unsupportedFilter;
  bool _lzError;
  bool _writeError;
+
+  bool _isSolid;
+  bool _solidAllowed;
+  bool _tableWasFilled;
+  bool _wasInit;
+
+  Byte _dictSizeLog;
  
  // CBitDecoder _bitStream;
  Byte *_window;
@@ -238,11 +245,6 @@ class CDecoder:
  UInt64 _writtenFileSize;
  size_t _winSizeAllocated;

-  Byte _dictSizeLog;
-  bool _tableWasFilled;
-  bool _isSolid;
-  bool _wasInit;
-
  UInt32 _reps[kNumReps];
  UInt32 _lastLen;