seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Compress/DeflateConst.h

@@ -6,37 +6,37 @@
 namespace NCompress {
 namespace NDeflate {
 
-const int kNumHuffmanBits = 15;
+const unsigned kNumHuffmanBits = 15;
 
 const UInt32 kHistorySize32 = (1 << 15);
 const UInt32 kHistorySize64 = (1 << 16);
 
-const UInt32 kDistTableSize32 = 30;
-const UInt32 kDistTableSize64 = 32;
+const unsigned kDistTableSize32 = 30;
+const unsigned kDistTableSize64 = 32;
   
-const UInt32 kNumLenSymbols32 = 256;
-const UInt32 kNumLenSymbols64 = 255; // don't change it. It must be <= 255.
-const UInt32 kNumLenSymbolsMax = kNumLenSymbols32;
+const unsigned kNumLenSymbols32 = 256;
+const unsigned kNumLenSymbols64 = 255; // don't change it. It must be <= 255.
+const unsigned kNumLenSymbolsMax = kNumLenSymbols32;
   
-const UInt32 kNumLenSlots = 29;
+const unsigned kNumLenSlots = 29;
 
-const UInt32 kFixedDistTableSize = 32;
-const UInt32 kFixedLenTableSize = 31;
+const unsigned kFixedDistTableSize = 32;
+const unsigned kFixedLenTableSize = 31;
 
-const UInt32 kSymbolEndOfBlock = 0x100;
-const UInt32 kSymbolMatch = kSymbolEndOfBlock + 1;
+const unsigned kSymbolEndOfBlock = 0x100;
+const unsigned kSymbolMatch = kSymbolEndOfBlock + 1;
 
-const UInt32 kMainTableSize = kSymbolMatch + kNumLenSlots;
-const UInt32 kFixedMainTableSize = kSymbolMatch + kFixedLenTableSize;
+const unsigned kMainTableSize = kSymbolMatch + kNumLenSlots;
+const unsigned kFixedMainTableSize = kSymbolMatch + kFixedLenTableSize;
 
-const UInt32 kLevelTableSize = 19;
+const unsigned kLevelTableSize = 19;
 
-const UInt32 kTableDirectLevels = 16;
-const UInt32 kTableLevelRepNumber = kTableDirectLevels;
-const UInt32 kTableLevel0Number = kTableLevelRepNumber + 1;
-const UInt32 kTableLevel0Number2 = kTableLevel0Number + 1;
+const unsigned kTableDirectLevels = 16;
+const unsigned kTableLevelRepNumber = kTableDirectLevels;
+const unsigned kTableLevel0Number = kTableLevelRepNumber + 1;
+const unsigned kTableLevel0Number2 = kTableLevel0Number + 1;
 
-const UInt32 kLevelMask = 0xF;
+const unsigned kLevelMask = 0xF;
 
 const Byte kLenStart32[kFixedLenTableSize] =
   {0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224, 255, 0, 0};
@@ -48,7 +48,7 @@ const Byte kLenDirectBits32[kFixedLenTableSize] =
 const Byte kLenDirectBits64[kFixedLenTableSize] =
   {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5, 16, 0, 0};
 
-const UInt32 kDistStart[kDistTableSize64]  =
+const UInt32 kDistStart[kDistTableSize64] =
   {0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,
   1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,32768,49152};
 const Byte kDistDirectBits[kDistTableSize64] =
@@ -58,12 +58,12 @@ const Byte kLevelDirectBits[3] = {2, 3, 7};
 
 const Byte kCodeLengthAlphabetOrder[kLevelTableSize] = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
 
-const UInt32 kMatchMinLen = 3;
-const UInt32 kMatchMaxLen32 = kNumLenSymbols32 + kMatchMinLen - 1; //256 + 2
-const UInt32 kMatchMaxLen64 = kNumLenSymbols64 + kMatchMinLen - 1; //255 + 2
-const UInt32 kMatchMaxLen = kMatchMaxLen32;
+const unsigned kMatchMinLen = 3;
+const unsigned kMatchMaxLen32 = kNumLenSymbols32 + kMatchMinLen - 1; // 256 + 2
+const unsigned kMatchMaxLen64 = kNumLenSymbols64 + kMatchMinLen - 1; // 255 + 2
+const unsigned kMatchMaxLen = kMatchMaxLen32;
 
-const int kFinalBlockFieldSize = 1;
+const unsigned kFinalBlockFieldSize = 1;
 
 namespace NFinalBlockField
 {
@@ -74,7 +74,7 @@ namespace NFinalBlockField
   };
 }
 
-const int kBlockTypeFieldSize = 2;
+const unsigned kBlockTypeFieldSize = 2;
 
 namespace NBlockType
 {
@@ -86,17 +86,17 @@ namespace NBlockType
   };
 }
 
-const int kNumLenCodesFieldSize = 5;
-const int kNumDistCodesFieldSize = 5;
-const int kNumLevelCodesFieldSize = 4;
+const unsigned kNumLenCodesFieldSize = 5;
+const unsigned kNumDistCodesFieldSize = 5;
+const unsigned kNumLevelCodesFieldSize = 4;
 
-const UInt32 kNumLitLenCodesMin = 257;
-const UInt32 kNumDistCodesMin = 1;
-const UInt32 kNumLevelCodesMin = 4;
+const unsigned kNumLitLenCodesMin = 257;
+const unsigned kNumDistCodesMin = 1;
+const unsigned kNumLevelCodesMin = 4;
 
-const int kLevelFieldSize = 3;
+const unsigned kLevelFieldSize = 3;
 
-const int kStoredBlockLengthFieldSize = 16;
+const unsigned kStoredBlockLengthFieldSize = 16;
 
 struct CLevels
 {
@@ -105,25 +105,22 @@ struct CLevels
 
   void SubClear()
   {
-    UInt32 i;
-    for(i = kNumLitLenCodesMin; i < kFixedMainTableSize; i++)
+    unsigned i;
+    for (i = kNumLitLenCodesMin; i < kFixedMainTableSize; i++)
       litLenLevels[i] = 0;
-    for(i = 0; i < kFixedDistTableSize; i++)
+    for (i = 0; i < kFixedDistTableSize; i++)
       distLevels[i] = 0;
   }
 
   void SetFixedLevels()
   {
-    int i;
+    unsigned i = 0;
+    
+    for (; i < 144; i++) litLenLevels[i] = 8;
+    for (; i < 256; i++) litLenLevels[i] = 9;
+    for (; i < 280; i++) litLenLevels[i] = 7;
+    for (; i < 288; i++) litLenLevels[i] = 8;
     
-    for (i = 0; i < 144; i++)
-      litLenLevels[i] = 8;
-    for (; i < 256; i++)
-      litLenLevels[i] = 9;
-    for (; i < 280; i++)
-      litLenLevels[i] = 7;
-    for (; i < 288; i++)
-      litLenLevels[i] = 8;
     for (i = 0; i < kFixedDistTableSize; i++)  // test it: InfoZip only uses kDistTableSize
       distLevels[i] = 5;
   }

data/ext/p7zip/CPP/7zip/Compress/DeflateDecoder.cpp

@@ -8,54 +8,69 @@ namespace NCompress {
 namespace NDeflate {
 namespace NDecoder {
 
-static const int kLenIdFinished = -1;
-static const int kLenIdNeedInit = -2;
-
 CCoder::CCoder(bool deflate64Mode, bool deflateNSIS):
     _deflate64Mode(deflate64Mode),
     _deflateNSIS(deflateNSIS),
     _keepHistory(false),
+    _needFinishInput(false),
     _needInitInStream(true),
     ZlibMode(false) {}
 
-UInt32 CCoder::ReadBits(int numBits)
+UInt32 CCoder::ReadBits(unsigned numBits)
 {
   return m_InBitStream.ReadBits(numBits);
 }
 
-bool CCoder::DeCodeLevelTable(Byte *values, int numSymbols)
+Byte CCoder::ReadAlignedByte()
 {
-  int i = 0;
+  return m_InBitStream.ReadAlignedByte();
+}
+
+bool CCoder::DecodeLevels(Byte *levels, unsigned numSymbols)
+{
+  unsigned i = 0;
+  
   do
   {
-    UInt32 number = m_LevelDecoder.DecodeSymbol(&m_InBitStream);
-    if (number < kTableDirectLevels)
-      values[i++] = (Byte)number;
-    else if (number < kLevelTableSize)
+    UInt32 sym = m_LevelDecoder.Decode(&m_InBitStream);
+    if (sym < kTableDirectLevels)
+      levels[i++] = (Byte)sym;
+    else
     {
-      if (number == kTableLevelRepNumber)
+      if (sym >= kLevelTableSize)
+        return false;
+      
+      unsigned num;
+      unsigned numBits;
+      Byte symbol;
+      
+      if (sym == kTableLevelRepNumber)
       {
         if (i == 0)
           return false;
-        int num = ReadBits(2) + 3;
-        for (; num > 0 && i < numSymbols; num--, i++)
-          values[i] = values[i - 1];
+        numBits = 2;
+        num = 0;
+        symbol = levels[i - 1];
       }
       else
       {
-        int num;
-        if (number == kTableLevel0Number)
-          num = ReadBits(3) + 3;
-        else
-          num = ReadBits(7) + 11;
-        for (;num > 0 && i < numSymbols; num--)
-          values[i++] = 0;
+        sym -= kTableLevel0Number;
+        sym <<= 2;
+        numBits = 3 + (unsigned)sym;
+        num = ((unsigned)sym << 1);
+        symbol = 0;
       }
+      
+      num += i + 3 + ReadBits(numBits);
+      if (num > numSymbols)
+        return false;
+      do
+        levels[i++] = symbol;
+      while (i < num);
     }
-    else
-      return false;
   }
-  while(i < numSymbols);
+  while (i < numSymbols);
+  
   return true;
 }
 
@@ -64,18 +79,22 @@ bool CCoder::DeCodeLevelTable(Byte *values, int numSymbols)
 bool CCoder::ReadTables(void)
 {
   m_FinalBlock = (ReadBits(kFinalBlockFieldSize) == NFinalBlockField::kFinalBlock);
+  if (m_InBitStream.ExtraBitsWereRead())
+    return false;
   UInt32 blockType = ReadBits(kBlockTypeFieldSize);
   if (blockType > NBlockType::kDynamicHuffman)
     return false;
+  if (m_InBitStream.ExtraBitsWereRead())
+    return false;
 
   if (blockType == NBlockType::kStored)
   {
     m_StoredMode = true;
     m_InBitStream.AlignToByte();
-    m_StoredBlockSize = ReadBits(kStoredBlockLengthFieldSize);
+    m_StoredBlockSize = ReadAligned_UInt16(); // ReadBits(kStoredBlockLengthFieldSize)
     if (_deflateNSIS)
       return true;
-    return (m_StoredBlockSize == (UInt16)~ReadBits(kStoredBlockLengthFieldSize));
+    return (m_StoredBlockSize == (UInt16)~ReadAligned_UInt16());
   }
 
   m_StoredMode = false;
@@ -88,39 +107,45 @@ bool CCoder::ReadTables(void)
   }
   else
   {
-    int numLitLenLevels = ReadBits(kNumLenCodesFieldSize) + kNumLitLenCodesMin;
+    unsigned numLitLenLevels = ReadBits(kNumLenCodesFieldSize) + kNumLitLenCodesMin;
     _numDistLevels = ReadBits(kNumDistCodesFieldSize) + kNumDistCodesMin;
-    int numLevelCodes = ReadBits(kNumLevelCodesFieldSize) + kNumLevelCodesMin;
+    unsigned numLevelCodes = ReadBits(kNumLevelCodesFieldSize) + kNumLevelCodesMin;
 
     if (!_deflate64Mode)
       if (_numDistLevels > kDistTableSize32)
         return false;
     
     Byte levelLevels[kLevelTableSize];
-    for (int i = 0; i < kLevelTableSize; i++)
+    for (unsigned i = 0; i < kLevelTableSize; i++)
     {
-      int position = kCodeLengthAlphabetOrder[i];
-      if(i < numLevelCodes)
+      unsigned position = kCodeLengthAlphabetOrder[i];
+      if (i < numLevelCodes)
         levelLevels[position] = (Byte)ReadBits(kLevelFieldSize);
       else
         levelLevels[position] = 0;
     }
     
-    RIF(m_LevelDecoder.SetCodeLengths(levelLevels));
+    if (m_InBitStream.ExtraBitsWereRead())
+      return false;
+
+    RIF(m_LevelDecoder.Build(levelLevels));
     
     Byte tmpLevels[kFixedMainTableSize + kFixedDistTableSize];
-    if (!DeCodeLevelTable(tmpLevels, numLitLenLevels + _numDistLevels))
+    if (!DecodeLevels(tmpLevels, numLitLenLevels + _numDistLevels))
+      return false;
+    
+    if (m_InBitStream.ExtraBitsWereRead())
       return false;
 
     levels.SubClear();
     memcpy(levels.litLenLevels, tmpLevels, numLitLenLevels);
     memcpy(levels.distLevels, tmpLevels + numLitLenLevels, _numDistLevels);
   }
-  RIF(m_MainDecoder.SetCodeLengths(levels.litLenLevels));
-  return m_DistDecoder.SetCodeLengths(levels.distLevels);
+  RIF(m_MainDecoder.Build(levels.litLenLevels));
+  return m_DistDecoder.Build(levels.distLevels);
 }
 
-HRESULT CCoder::CodeSpec(UInt32 curSize)
+HRESULT CCoder::CodeSpec(UInt32 curSize, bool finishInputStream)
 {
   if (_remainLen == kLenIdFinished)
     return S_OK;
@@ -136,10 +161,7 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
     _needReadTable = true;
   }
 
-  if (curSize == 0)
-    return S_OK;
-
-  while(_remainLen > 0 && curSize > 0)
+  while (_remainLen > 0 && curSize > 0)
   {
     _remainLen--;
     Byte b = m_OutWindowStream.GetByte(_rep0);
@@ -147,8 +169,11 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
     curSize--;
   }
 
-  while(curSize > 0)
+  while (curSize > 0 || finishInputStream)
   {
+    if (m_InBitStream.ExtraBitsWereRead())
+      return S_FALSE;
+
     if (_needReadTable)
     {
       if (m_FinalBlock)
@@ -158,58 +183,68 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
       }
       if (!ReadTables())
         return S_FALSE;
+      if (m_InBitStream.ExtraBitsWereRead())
+        return S_FALSE;
       _needReadTable = false;
     }
 
-    if(m_StoredMode)
+    if (m_StoredMode)
     {
+      if (finishInputStream && curSize == 0 && m_StoredBlockSize != 0)
+        return S_FALSE;
+      /* NSIS version contains some bits in bitl bits buffer.
+         So we must read some first bytes via ReadAlignedByte */
+      for (; m_StoredBlockSize > 0 && curSize > 0 && m_InBitStream.ThereAreDataInBitsBuffer(); m_StoredBlockSize--, curSize--)
+        m_OutWindowStream.PutByte(ReadAlignedByte());
       for (; m_StoredBlockSize > 0 && curSize > 0; m_StoredBlockSize--, curSize--)
-        m_OutWindowStream.PutByte(m_InBitStream.ReadByte());
+        m_OutWindowStream.PutByte(m_InBitStream.ReadDirectByte());
       _needReadTable = (m_StoredBlockSize == 0);
       continue;
     }
-    while(curSize > 0)
+    
+    while (curSize > 0)
     {
-      if (m_InBitStream.NumExtraBytes > 4)
+      if (m_InBitStream.ExtraBitsWereRead_Fast())
         return S_FALSE;
 
-      UInt32 number = m_MainDecoder.DecodeSymbol(&m_InBitStream);
-      if (number < 0x100)
+      UInt32 sym = m_MainDecoder.Decode(&m_InBitStream);
+
+      if (sym < 0x100)
       {
-        m_OutWindowStream.PutByte((Byte)number);
+        m_OutWindowStream.PutByte((Byte)sym);
         curSize--;
         continue;
       }
-      else if (number == kSymbolEndOfBlock)
+      else if (sym == kSymbolEndOfBlock)
       {
         _needReadTable = true;
         break;
       }
-      else if (number < kMainTableSize)
+      else if (sym < kMainTableSize)
       {
-        number -= kSymbolMatch;
+        sym -= kSymbolMatch;
         UInt32 len;
         {
-          int numBits;
+          unsigned numBits;
           if (_deflate64Mode)
           {
-            len = kLenStart64[number];
-            numBits = kLenDirectBits64[number];
+            len = kLenStart64[sym];
+            numBits = kLenDirectBits64[sym];
           }
           else
           {
-            len = kLenStart32[number];
-            numBits = kLenDirectBits32[number];
+            len = kLenStart32[sym];
+            numBits = kLenDirectBits32[sym];
           }
           len += kMatchMinLen + m_InBitStream.ReadBits(numBits);
         }
         UInt32 locLen = len;
         if (locLen > curSize)
           locLen = (UInt32)curSize;
-        number = m_DistDecoder.DecodeSymbol(&m_InBitStream);
-        if (number >= _numDistLevels)
+        sym = m_DistDecoder.Decode(&m_InBitStream);
+        if (sym >= _numDistLevels)
           return S_FALSE;
-        UInt32 distance = kDistStart[number] + m_InBitStream.ReadBits(kDistDirectBits[number]);
+        UInt32 distance = kDistStart[sym] + m_InBitStream.ReadBits(kDistDirectBits[sym]);
         if (!m_OutWindowStream.CopyBlock(distance, locLen))
           return S_FALSE;
         curSize -= locLen;
@@ -224,67 +259,89 @@ HRESULT CCoder::CodeSpec(UInt32 curSize)
       else
         return S_FALSE;
     }
+    
+    if (finishInputStream && curSize == 0)
+    {
+      if (m_MainDecoder.Decode(&m_InBitStream) != kSymbolEndOfBlock)
+        return S_FALSE;
+      _needReadTable = true;
+    }
   }
+
+  if (m_InBitStream.ExtraBitsWereRead())
+    return S_FALSE;
+
   return S_OK;
 }
 
+
 #ifdef _NO_EXCEPTIONS
 
 #define DEFLATE_TRY_BEGIN
-#define DEFLATE_TRY_END
+#define DEFLATE_TRY_END(res)
 
 #else
 
 #define DEFLATE_TRY_BEGIN try {
-#define DEFLATE_TRY_END } \
-  catch(const CInBufferException &e)  { return e.ErrorCode; } \
-  catch(const CLzOutWindowException &e)  { return e.ErrorCode; } \
-  catch(...) { return S_FALSE; }
+#define DEFLATE_TRY_END(res) } \
+  catch(const CInBufferException &e)  { res = e.ErrorCode; } \
+  catch(const CLzOutWindowException &e)  { res = e.ErrorCode; } \
+  catch(...) { res = S_FALSE; }
 
 #endif
 
+
 HRESULT CCoder::CodeReal(ISequentialOutStream *outStream,
       const UInt64 *outSize, ICompressProgressInfo *progress)
 {
+  HRESULT res;
   DEFLATE_TRY_BEGIN
   m_OutWindowStream.SetStream(outStream);
   CCoderReleaser flusher(this);
 
   const UInt64 inStart = _needInitInStream ? 0 : m_InBitStream.GetProcessedSize();
   const UInt64 start = m_OutWindowStream.GetProcessedSize();
+
   for (;;)
   {
     UInt32 curSize = 1 << 18;
-    if (outSize != 0)
+    bool finishInputStream = false;
+    if (outSize)
     {
       const UInt64 rem = *outSize - (m_OutWindowStream.GetProcessedSize() - start);
-      if (curSize > rem)
+      if (curSize >= rem)
+      {
         curSize = (UInt32)rem;
+        if (ZlibMode || _needFinishInput)
+          finishInputStream = true;
+      }
     }
-    if (curSize == 0)
+    if (!finishInputStream && curSize == 0)
       break;
-    RINOK(CodeSpec(curSize));
+    RINOK(CodeSpec(curSize, finishInputStream));
     if (_remainLen == kLenIdFinished)
       break;
-    if (progress != NULL)
+    if (progress)
     {
       const UInt64 inSize = m_InBitStream.GetProcessedSize() - inStart;
       const UInt64 nowPos64 = m_OutWindowStream.GetProcessedSize() - start;
       RINOK(progress->SetRatioInfo(&inSize, &nowPos64));
     }
   }
+  
   if (_remainLen == kLenIdFinished && ZlibMode)
   {
     m_InBitStream.AlignToByte();
-    for (int i = 0; i < 4; i++)
-      ZlibFooter[i] = m_InBitStream.ReadByte();
+    for (unsigned i = 0; i < 4; i++)
+      ZlibFooter[i] = ReadAlignedByte();
   }
+  
   flusher.NeedFlush = false;
-  HRESULT res = Flush();
-  if (res == S_OK && InputEofError())
+  res = Flush();
+  if (res == S_OK && _remainLen != kLenIdNeedInit && InputEofError())
     return S_FALSE;
+  DEFLATE_TRY_END(res)
   return res;
-  DEFLATE_TRY_END
 }
 
 HRESULT CCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
@@ -299,7 +356,7 @@ HRESULT CCoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStr
 
 STDMETHODIMP CCoder::GetInStreamProcessedSize(UInt64 *value)
 {
-  if (value == NULL)
+  if (!value)
     return E_INVALIDARG;
   *value = m_InBitStream.GetProcessedSize();
   return S_OK;
@@ -307,13 +364,14 @@ STDMETHODIMP CCoder::GetInStreamProcessedSize(UInt64 *value)
 
 STDMETHODIMP CCoder::SetInStream(ISequentialInStream *inStream)
 {
+  m_InStreamRef = inStream;
   m_InBitStream.SetStream(inStream);
   return S_OK;
 }
 
 STDMETHODIMP CCoder::ReleaseInStream()
 {
-  m_InBitStream.ReleaseStream();
+  m_InStreamRef.Release();
   return S_OK;
 }
 
@@ -329,16 +387,22 @@ STDMETHODIMP CCoder::SetOutStreamSize(const UInt64 * /* outSize */)
 
 STDMETHODIMP CCoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
+  HRESULT res;
   DEFLATE_TRY_BEGIN
   if (processedSize)
     *processedSize = 0;
   const UInt64 startPos = m_OutWindowStream.GetProcessedSize();
   m_OutWindowStream.SetMemStream((Byte *)data);
-  RINOK(CodeSpec(size));
-  if (processedSize)
-    *processedSize = (UInt32)(m_OutWindowStream.GetProcessedSize() - startPos);
-  return Flush();
-  DEFLATE_TRY_END
+  res = CodeSpec(size, false);
+  if (res == S_OK)
+  {
+    res = Flush();
+    if (processedSize)
+      *processedSize = (UInt32)(m_OutWindowStream.GetProcessedSize() - startPos);
+  }
+  DEFLATE_TRY_END(res)
+  m_OutWindowStream.SetMemStream(NULL);
+  return res;
 }
 
 #endif