seven_zip_ruby_am 1.2.5.1

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

@@ -0,0 +1,14 @@
+// LzOutWindow.cpp
+
+#include "StdAfx.h"
+
+#include "LzOutWindow.h"
+
+void CLzOutWindow::Init(bool solid)
+{
+  if (!solid)
+    COutBuffer::Init();
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = S_OK;
+  #endif
+}

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

@@ -0,0 +1,66 @@
+// LzOutWindow.h
+
+#ifndef __LZ_OUT_WINDOW_H
+#define __LZ_OUT_WINDOW_H
+
+#include "../IStream.h"
+
+#include "../Common/OutBuffer.h"
+
+#ifndef _NO_EXCEPTIONS
+typedef COutBufferException CLzOutWindowException;
+#endif
+
+class CLzOutWindow: public COutBuffer
+{
+public:
+  void Init(bool solid = false);
+  
+  // distance >= 0, len > 0,
+  bool CopyBlock(UInt32 distance, UInt32 len)
+  {
+    UInt32 pos = _pos - distance - 1;
+    if (distance >= _pos)
+    {
+      if (!_overDict || distance >= _bufferSize)
+        return false;
+      pos += _bufferSize;
+    }
+    if (_limitPos - _pos > len && _bufferSize - pos > len)
+    {
+      const Byte *src = _buffer + pos;
+      Byte *dest = _buffer + _pos;
+      _pos += len;
+      do
+        *dest++ = *src++;
+      while(--len != 0);
+    }
+    else do
+    {
+      if (pos == _bufferSize)
+        pos = 0;
+      _buffer[_pos++] = _buffer[pos++];
+      if (_pos == _limitPos)
+        FlushWithCheck();
+    }
+    while(--len != 0);
+    return true;
+  }
+  
+  void PutByte(Byte b)
+  {
+    _buffer[_pos++] = b;
+    if (_pos == _limitPos)
+      FlushWithCheck();
+  }
+  
+  Byte GetByte(UInt32 distance) const
+  {
+    UInt32 pos = _pos - distance - 1;
+    if (pos >= _bufferSize)
+      pos += _bufferSize;
+    return _buffer[pos];
+  }
+};
+
+#endif

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

@@ -0,0 +1,220 @@
+// LzhDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "LzhDecoder.h"
+
+#include "Windows/Defs.h"
+
+namespace NCompress{
+namespace NLzh {
+namespace NDecoder {
+
+static const UInt32 kHistorySize = (1 << 16);
+
+static const int kBlockSizeBits = 16;
+static const int kNumCBits = 9;
+static const int kNumLevelBits = 5; // smallest integer such that (1 << kNumLevelBits) > kNumLevelSymbols/
+
+UInt32 CCoder::ReadBits(int numBits) {  return m_InBitStream.ReadBits(numBits); }
+
+HRESULT CCoder::ReadLevelTable()
+{
+  int n = ReadBits(kNumLevelBits);
+  if (n == 0)
+  {
+    m_LevelHuffman.Symbol = ReadBits(kNumLevelBits);
+    if (m_LevelHuffman.Symbol >= kNumLevelSymbols)
+      return S_FALSE;
+  }
+  else
+  {
+    if (n > kNumLevelSymbols)
+      return S_FALSE;
+    m_LevelHuffman.Symbol = -1;
+    Byte lens[kNumLevelSymbols];
+    int i = 0;
+    while (i < n)
+    {
+      int c = m_InBitStream.ReadBits(3);
+      if (c == 7)
+        while (ReadBits(1))
+          if (c++ > kMaxHuffmanLen)
+            return S_FALSE;
+      lens[i++] = (Byte)c;
+      if (i == kNumSpecLevelSymbols)
+      {
+        c = ReadBits(2);
+        while (--c >= 0)
+          lens[i++] = 0;
+      }
+    }
+    while (i < kNumLevelSymbols)
+      lens[i++] = 0;
+    m_LevelHuffman.SetCodeLengths(lens);
+  }
+  return S_OK;
+}
+
+HRESULT CCoder::ReadPTable(int numBits)
+{
+  int n = ReadBits(numBits);
+  if (n == 0)
+  {
+    m_PHuffmanDecoder.Symbol = ReadBits(numBits);
+    if (m_PHuffmanDecoder.Symbol >= kNumDistanceSymbols)
+      return S_FALSE;
+  }
+  else
+  {
+    if (n > kNumDistanceSymbols)
+      return S_FALSE;
+    m_PHuffmanDecoder.Symbol = -1;
+    Byte lens[kNumDistanceSymbols];
+    int i = 0;
+    while (i < n)
+    {
+      int c = m_InBitStream.ReadBits(3);
+      if (c == 7)
+        while (ReadBits(1))
+        {
+          if (c > kMaxHuffmanLen)
+            return S_FALSE;
+          c++;
+        }
+      lens[i++] = (Byte)c;
+    }
+    while (i < kNumDistanceSymbols)
+      lens[i++] = 0;
+    m_PHuffmanDecoder.SetCodeLengths(lens);
+  }
+  return S_OK;
+}
+
+HRESULT CCoder::ReadCTable()
+{
+  int n = ReadBits(kNumCBits);
+  if (n == 0)
+  {
+    m_CHuffmanDecoder.Symbol = ReadBits(kNumCBits);
+    if (m_CHuffmanDecoder.Symbol >= kNumCSymbols)
+      return S_FALSE;
+  }
+  else
+  {
+    if (n > kNumCSymbols)
+      return S_FALSE;
+    m_CHuffmanDecoder.Symbol = -1;
+    Byte lens[kNumCSymbols];
+    int i = 0;
+    while (i < n)
+    {
+      int c = m_LevelHuffman.Decode(&m_InBitStream);
+      if (c < kNumSpecLevelSymbols)
+      {
+        if (c == 0)
+          c = 1;
+        else if (c == 1)
+          c = ReadBits(4) + 3;
+        else
+          c = ReadBits(kNumCBits) + 20;
+        while (--c >= 0)
+        {
+          if (i > kNumCSymbols)
+            return S_FALSE;
+          lens[i++] = 0;
+        }
+      }
+      else
+        lens[i++] = (Byte)(c - 2);
+    }
+    while (i < kNumCSymbols)
+      lens[i++] = 0;
+    m_CHuffmanDecoder.SetCodeLengths(lens);
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CCoder::CodeReal(ISequentialInStream *inStream,
+    ISequentialOutStream *outStream, const UInt64 * /* inSize */, const UInt64 *outSize,
+    ICompressProgressInfo *progress)
+{
+  if (outSize == NULL)
+    return E_INVALIDARG;
+
+  if (!m_OutWindowStream.Create(kHistorySize))
+    return E_OUTOFMEMORY;
+  if (!m_InBitStream.Create(1 << 20))
+    return E_OUTOFMEMORY;
+
+  UInt64 pos = 0;
+  m_OutWindowStream.SetStream(outStream);
+  m_OutWindowStream.Init(false);
+  m_InBitStream.SetStream(inStream);
+  m_InBitStream.Init();
+  
+  CCoderReleaser coderReleaser(this);
+
+  int pbit;
+  if (m_NumDictBits <= 13)
+    pbit = 4;
+  else
+    pbit = 5;
+
+  UInt32 blockSize = 0;
+
+  while(pos < *outSize)
+  {
+    // for (i = 0; i < dictSize; i++) dtext[i] = 0x20;
+    
+    if (blockSize == 0)
+    {
+      if (progress != NULL)
+      {
+        UInt64 packSize = m_InBitStream.GetProcessedSize();
+        RINOK(progress->SetRatioInfo(&packSize, &pos));
+      }
+      blockSize = ReadBits(kBlockSizeBits);
+      ReadLevelTable();
+      ReadCTable();
+      RINOK(ReadPTable(pbit));
+    }
+    blockSize--;
+    UInt32 c = m_CHuffmanDecoder.Decode(&m_InBitStream);
+    if (c < 256)
+    {
+      m_OutWindowStream.PutByte((Byte)c);
+      pos++;
+    }
+    else if (c >= kNumCSymbols)
+      return S_FALSE;
+    else
+    {
+      // offset = (interface->method == LARC_METHOD_NUM) ? 0x100 - 2 : 0x100 - 3;
+      UInt32 len  = c - 256 + kMinMatch;
+      UInt32 distance = m_PHuffmanDecoder.Decode(&m_InBitStream);
+      if (distance != 0)
+        distance = (1 << (distance - 1)) + ReadBits(distance - 1);
+      if (distance >= pos)
+        return S_FALSE;
+      if (pos + len > *outSize)
+        len = (UInt32)(*outSize - pos);
+      pos += len;
+      m_OutWindowStream.CopyBlock(distance, len);
+    }
+  }
+  coderReleaser.NeedFlush = false;
+  return m_OutWindowStream.Flush();
+}
+
+STDMETHODIMP CCoder::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) { return e.ErrorCode; }
+  catch(const CLzOutWindowException &e) { return e.ErrorCode; }
+  catch(...) { return S_FALSE; }
+}
+
+}}}

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

@@ -0,0 +1,106 @@
+// LzhDecoder.h
+
+#ifndef __COMPRESS_LZH_DECODER_H
+#define __COMPRESS_LZH_DECODER_H
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+#include "../Common/InBuffer.h"
+
+#include "BitmDecoder.h"
+#include "HuffmanDecoder.h"
+#include "LzOutWindow.h"
+
+namespace NCompress {
+namespace NLzh {
+namespace NDecoder {
+
+const int kMaxHuffmanLen = 16; // Check it
+
+const int kNumSpecLevelSymbols = 3;
+const int kNumLevelSymbols = kNumSpecLevelSymbols + kMaxHuffmanLen;
+
+const int kDictBitsMax = 16;
+const int kNumDistanceSymbols = kDictBitsMax + 1;
+
+const int kMaxMatch = 256;
+const int kMinMatch = 3;
+const int kNumCSymbols = 256 + kMaxMatch + 2 - kMinMatch;
+
+template <UInt32 m_NumSymbols>
+class CHuffmanDecoder:public NCompress::NHuffman::CDecoder<kMaxHuffmanLen, m_NumSymbols>
+{
+public:
+  int Symbol;
+  template <class TBitDecoder>
+  UInt32 Decode(TBitDecoder *bitStream)
+  {
+    if (Symbol >= 0)
+      return (UInt32)Symbol;
+    return this->DecodeSymbol(bitStream);
+  }
+};
+
+class CCoder :
+  public ICompressCoder,
+  public CMyUnknownImp
+{
+  CLzOutWindow m_OutWindowStream;
+  NBitm::CDecoder<CInBuffer> m_InBitStream;
+
+  int m_NumDictBits;
+
+  CHuffmanDecoder<kNumLevelSymbols> m_LevelHuffman;
+  CHuffmanDecoder<kNumDistanceSymbols> m_PHuffmanDecoder;
+  CHuffmanDecoder<kNumCSymbols> m_CHuffmanDecoder;
+
+  void ReleaseStreams()
+  {
+    m_OutWindowStream.ReleaseStream();
+    m_InBitStream.ReleaseStream();
+  }
+
+  class CCoderReleaser
+  {
+    CCoder *m_Coder;
+  public:
+    bool NeedFlush;
+    CCoderReleaser(CCoder *coder): m_Coder(coder), NeedFlush(true) {}
+    ~CCoderReleaser()
+    {
+      if (NeedFlush)
+        m_Coder->m_OutWindowStream.Flush();
+      m_Coder->ReleaseStreams();
+    }
+  };
+  friend class CCoderReleaser;
+
+  void MakeTable(int nchar, Byte *bitlen, int tablebits,
+      UInt32 *table, int tablesize);
+  
+  UInt32 ReadBits(int numBits);
+  HRESULT ReadLevelTable();
+  HRESULT ReadPTable(int numBits);
+  HRESULT ReadCTable();
+
+public:
+  
+  MY_UNKNOWN_IMP
+
+  STDMETHOD(CodeReal)(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
+      ICompressProgressInfo *progress);
+
+  STDMETHOD(Code)(ISequentialInStream *inStream,
+      ISequentialOutStream *outStream, const UInt64 *inSize, const UInt64 *outSize,
+      ICompressProgressInfo *progress);
+
+  void SetDictionary(int numDictBits) { m_NumDictBits = numDictBits; }
+  CCoder(): m_NumDictBits(0) {}
+};
+
+}}}
+
+#endif

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

@@ -0,0 +1,189 @@
+// Lzma2Decoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "Lzma2Decoder.h"
+
+static HRESULT SResToHRESULT(SRes res)
+{
+  switch(res)
+  {
+    case SZ_OK: return S_OK;
+    case SZ_ERROR_MEM: return E_OUTOFMEMORY;
+    case SZ_ERROR_PARAM: return E_INVALIDARG;
+    // case SZ_ERROR_PROGRESS: return E_ABORT;
+    case SZ_ERROR_DATA: return S_FALSE;
+  }
+  return E_FAIL;
+}
+
+namespace NCompress {
+namespace NLzma2 {
+
+static const UInt32 kInBufSize = 1 << 20;
+
+CDecoder::CDecoder(): _inBuf(0), _outSizeDefined(false)
+{
+  Lzma2Dec_Construct(&_state);
+}
+
+static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
+static void SzFree(void *p, void *address) { p = p; MyFree(address); }
+static ISzAlloc g_Alloc = { SzAlloc, SzFree };
+
+CDecoder::~CDecoder()
+{
+  Lzma2Dec_Free(&_state, &g_Alloc);
+  MyFree(_inBuf);
+}
+
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
+{
+  if (size != 1) return SZ_ERROR_UNSUPPORTED;
+  RINOK(SResToHRESULT(Lzma2Dec_Allocate(&_state, prop[0], &g_Alloc)));
+  if (_inBuf == 0)
+  {
+    _inBuf = (Byte *)MyAlloc(kInBufSize);
+    if (_inBuf == 0)
+      return E_OUTOFMEMORY;
+  }
+
+  return S_OK;
+}
+
+STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value) { *value = _inSizeProcessed; return S_OK; }
+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { _inStream = inStream; return S_OK; }
+STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
+
+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
+{
+  _outSizeDefined = (outSize != NULL);
+  if (_outSizeDefined)
+    _outSize = *outSize;
+
+  Lzma2Dec_Init(&_state);
+  
+  _inPos = _inSize = 0;
+  _inSizeProcessed = _outSizeProcessed = 0;
+  return S_OK;
+}
+
+STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream,
+    ISequentialOutStream *outStream, const UInt64 * /* inSize */,
+    const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+  if (_inBuf == 0)
+    return S_FALSE;
+  SetOutStreamSize(outSize);
+
+  for (;;)
+  {
+    if (_inPos == _inSize)
+    {
+      _inPos = _inSize = 0;
+      RINOK(inStream->Read(_inBuf, kInBufSize, &_inSize));
+    }
+
+    SizeT dicPos = _state.decoder.dicPos;
+    SizeT curSize = _state.decoder.dicBufSize - dicPos;
+    const UInt32 kStepSize = ((UInt32)1 << 22);
+    if (curSize > kStepSize)
+      curSize = (SizeT)kStepSize;
+    
+    ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+    if (_outSizeDefined)
+    {
+      const UInt64 rem = _outSize - _outSizeProcessed;
+      if (rem < curSize)
+      {
+        curSize = (SizeT)rem;
+        /*
+        // finishMode = LZMA_FINISH_END;
+        we can't use LZMA_FINISH_END here to allow partial decoding
+        */
+      }
+    }
+
+    SizeT inSizeProcessed = _inSize - _inPos;
+    ELzmaStatus status;
+    SRes res = Lzma2Dec_DecodeToDic(&_state, dicPos + curSize, _inBuf + _inPos, &inSizeProcessed, finishMode, &status);
+
+    _inPos += (UInt32)inSizeProcessed;
+    _inSizeProcessed += inSizeProcessed;
+    SizeT outSizeProcessed = _state.decoder.dicPos - dicPos;
+    _outSizeProcessed += outSizeProcessed;
+
+    bool finished = (inSizeProcessed == 0 && outSizeProcessed == 0);
+    bool stopDecoding = (_outSizeDefined && _outSizeProcessed >= _outSize);
+
+    if (res != 0 || _state.decoder.dicPos == _state.decoder.dicBufSize || finished || stopDecoding)
+    {
+      HRESULT res2 = WriteStream(outStream, _state.decoder.dic, _state.decoder.dicPos);
+      if (res != 0)
+        return S_FALSE;
+      RINOK(res2);
+      if (stopDecoding)
+        return S_OK;
+      if (finished)
+        return (status == LZMA_STATUS_FINISHED_WITH_MARK ? S_OK : S_FALSE);
+    }
+    if (_state.decoder.dicPos == _state.decoder.dicBufSize)
+      _state.decoder.dicPos = 0;
+
+    if (progress != NULL)
+    {
+      RINOK(progress->SetRatioInfo(&_inSizeProcessed, &_outSizeProcessed));
+    }
+  }
+}
+
+#ifndef NO_READ_FROM_CODER
+
+STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  do
+  {
+    if (_inPos == _inSize)
+    {
+      _inPos = _inSize = 0;
+      RINOK(_inStream->Read(_inBuf, kInBufSize, &_inSize));
+    }
+    {
+      SizeT inProcessed = _inSize - _inPos;
+
+      if (_outSizeDefined)
+      {
+        const UInt64 rem = _outSize - _outSizeProcessed;
+        if (rem < size)
+          size = (UInt32)rem;
+      }
+
+      SizeT outProcessed = size;
+      ELzmaStatus status;
+      SRes res = Lzma2Dec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
+          _inBuf + _inPos, &inProcessed, LZMA_FINISH_ANY, &status);
+      _inPos += (UInt32)inProcessed;
+      _inSizeProcessed += inProcessed;
+      _outSizeProcessed += outProcessed;
+      size -= (UInt32)outProcessed;
+      data = (Byte *)data + outProcessed;
+      if (processedSize)
+        *processedSize += (UInt32)outProcessed;
+      RINOK(SResToHRESULT(res));
+      if (inProcessed == 0 && outProcessed == 0)
+        return S_OK;
+    }
+  }
+  while (size != 0);
+  return S_OK;
+}
+
+#endif
+
+}}