seven_zip_ruby 1.0.0

data/ext/p7zip/CPP/7zip/Common/StreamObjects.h

@@ -0,0 +1,135 @@
+// StreamObjects.h
+
+#ifndef __STREAM_OBJECTS_H
+#define __STREAM_OBJECTS_H
+
+#include "../../Common/Buffer.h"
+#include "../../Common/MyCom.h"
+#include "../IStream.h"
+
+struct CReferenceBuf:
+  public IUnknown,
+  public CMyUnknownImp
+{
+  CByteBuffer Buf;
+  MY_UNKNOWN_IMP
+};
+
+class CBufInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  const Byte *_data;
+  UInt64 _pos;
+  size_t _size;
+  CMyComPtr<IUnknown> _ref;
+public:
+  void Init(const Byte *data, size_t size, IUnknown *ref = 0)
+  {
+    _data = data;
+    _size = size;
+    _pos = 0;
+    _ref = ref;
+  }
+  void Init(CReferenceBuf *ref) { Init(ref->Buf, ref->Buf.GetCapacity(), ref); }
+
+  MY_UNKNOWN_IMP1(IInStream)
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+};
+
+class CByteDynBuffer
+{
+  size_t _capacity;
+  Byte *_buf;
+public:
+  CByteDynBuffer(): _capacity(0), _buf(0) {};
+  // there is no copy constructor. So don't copy this object.
+  ~CByteDynBuffer() { Free(); }
+  void Free();
+  size_t GetCapacity() const { return  _capacity; }
+  operator Byte*() const { return _buf; };
+  operator const Byte*() const { return _buf; };
+  bool EnsureCapacity(size_t capacity);
+};
+
+class CDynBufSeqOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  CByteDynBuffer _buffer;
+  size_t _size;
+public:
+  CDynBufSeqOutStream(): _size(0) {}
+  void Init() { _size = 0;  }
+  size_t GetSize() const { return _size; }
+  const Byte *GetBuffer() const { return _buffer; }
+  void CopyToBuffer(CByteBuffer &dest) const;
+  Byte *GetBufPtrForWriting(size_t addSize);
+  void UpdateSize(size_t addSize) { _size += addSize; }
+
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+class CBufPtrSeqOutStream:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  Byte *_buffer;
+  size_t _size;
+  size_t _pos;
+public:
+  void Init(Byte *buffer, size_t size)
+  {
+    _buffer = buffer;
+    _pos = 0;
+    _size = size;
+  }
+  size_t GetPos() const { return _pos; }
+
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+class CSequentialOutStreamSizeCount:
+  public ISequentialOutStream,
+  public CMyUnknownImp
+{
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt64 _size;
+public:
+  void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+  void Init() { _size = 0; }
+  UInt64 GetSize() const { return _size; }
+
+  MY_UNKNOWN_IMP
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+};
+
+class CCachedInStream:
+  public IInStream,
+  public CMyUnknownImp
+{
+  UInt64 *_tags;
+  Byte *_data;
+  size_t _dataSize;
+  unsigned _blockSizeLog;
+  unsigned _numBlocksLog;
+  UInt64 _size;
+  UInt64 _pos;
+protected:
+  virtual HRESULT ReadBlock(UInt64 blockIndex, Byte *dest, size_t blockSize) = 0;
+public:
+  CCachedInStream(): _tags(0), _data(0) {}
+  virtual ~CCachedInStream() { Free(); } // the destructor must be virtual (release calls it) !!!
+  void Free();
+  bool Alloc(unsigned blockSizeLog, unsigned numBlocksLog);
+  void Init(UInt64 size);
+
+  MY_UNKNOWN_IMP2(ISequentialInStream, IInStream)
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+};
+
+#endif

data/ext/p7zip/CPP/7zip/Common/StreamUtils.cpp

@@ -0,0 +1,56 @@
+// StreamUtils.cpp
+
+#include "StdAfx.h"
+
+#include "StreamUtils.h"
+
+static const UInt32 kBlockSize = ((UInt32)1 << 31);
+
+HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *processedSize)
+{
+  size_t size = *processedSize;
+  *processedSize = 0;
+  while (size != 0)
+  {
+    UInt32 curSize = (size < kBlockSize) ? (UInt32)size : kBlockSize;
+    UInt32 processedSizeLoc;
+    HRESULT res = stream->Read(data, curSize, &processedSizeLoc);
+    *processedSize += processedSizeLoc;
+    data = (void *)((Byte *)data + processedSizeLoc);
+    size -= processedSizeLoc;
+    RINOK(res);
+    if (processedSizeLoc == 0)
+      return S_OK;
+  }
+  return S_OK;
+}
+
+HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size)
+{
+  size_t processedSize = size;
+  RINOK(ReadStream(stream, data, &processedSize));
+  return (size == processedSize) ? S_OK : S_FALSE;
+}
+
+HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size)
+{
+  size_t processedSize = size;
+  RINOK(ReadStream(stream, data, &processedSize));
+  return (size == processedSize) ? S_OK : E_FAIL;
+}
+
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size)
+{
+  while (size != 0)
+  {
+    UInt32 curSize = (size < kBlockSize) ? (UInt32)size : kBlockSize;
+    UInt32 processedSizeLoc;
+    HRESULT res = stream->Write(data, curSize, &processedSizeLoc);
+    data = (const void *)((const Byte *)data + processedSizeLoc);
+    size -= processedSizeLoc;
+    RINOK(res);
+    if (processedSizeLoc == 0)
+      return E_FAIL;
+  }
+  return S_OK;
+}

data/ext/p7zip/CPP/7zip/Common/StreamUtils.h

@@ -0,0 +1,13 @@
+// StreamUtils.h
+
+#ifndef __STREAMUTILS_H
+#define __STREAMUTILS_H
+
+#include "../IStream.h"
+
+HRESULT ReadStream(ISequentialInStream *stream, void *data, size_t *size);
+HRESULT ReadStream_FALSE(ISequentialInStream *stream, void *data, size_t size);
+HRESULT ReadStream_FAIL(ISequentialInStream *stream, void *data, size_t size);
+HRESULT WriteStream(ISequentialOutStream *stream, const void *data, size_t size);
+
+#endif

data/ext/p7zip/CPP/7zip/Common/VirtThread.cpp

@@ -0,0 +1,46 @@
+// VirtThread.cpp
+
+#include "StdAfx.h"
+
+#include "VirtThread.h"
+
+static THREAD_FUNC_DECL CoderThread(void *p)
+{
+  for (;;)
+  {
+    CVirtThread *t = (CVirtThread *)p;
+    t->StartEvent.Lock();
+    if (t->ExitEvent)
+      return 0;
+    t->Execute();
+    t->FinishedEvent.Set();
+  }
+}
+
+WRes CVirtThread::Create()
+{
+  RINOK(StartEvent.CreateIfNotCreated());
+  RINOK(FinishedEvent.CreateIfNotCreated());
+  StartEvent.Reset();
+  FinishedEvent.Reset();
+  ExitEvent = false;
+  if (Thread.IsCreated())
+    return S_OK;
+  return Thread.Create(CoderThread, this);
+}
+
+void CVirtThread::Start()
+{
+  ExitEvent = false;
+  StartEvent.Set();
+}
+
+CVirtThread::~CVirtThread()
+{
+  ExitEvent = true;
+  if (StartEvent.IsCreated())
+    StartEvent.Set();
+  if (Thread.IsCreated())
+    Thread.Wait();
+}
+

data/ext/p7zip/CPP/7zip/Common/VirtThread.h

@@ -0,0 +1,23 @@
+// VirtThread.h
+
+#ifndef __VIRTTHREAD_H
+#define __VIRTTHREAD_H
+
+#include "../../Windows/Synchronization.h"
+#include "../../Windows/Thread.h"
+
+struct CVirtThread
+{
+  NWindows::NSynchronization::CAutoResetEvent StartEvent;
+  NWindows::NSynchronization::CAutoResetEvent FinishedEvent;
+  NWindows::CThread Thread;
+  bool ExitEvent;
+
+  ~CVirtThread();
+  WRes Create();
+  void Start();
+  void WaitFinish() { FinishedEvent.Lock(); }
+  virtual void Execute() = 0;
+};
+
+#endif

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

@@ -0,0 +1,309 @@
+// ArjDecoder1.cpp
+
+#include "StdAfx.h"
+
+#include "ArjDecoder1.h"
+
+namespace NCompress{
+namespace NArj {
+namespace NDecoder1 {
+
+static const UInt32 kHistorySize = 26624;
+static const UInt32 kMatchMinLen = 3;
+static const UInt32 kMatchMaxLen = 256;
+
+// static const UInt32 kNC = 255 + kMatchMaxLen + 2 - kMatchMinLen;
+
+void CCoder::MakeTable(int nchar, Byte *bitlen, int tablebits,
+    UInt32 *table, int tablesize)
+{
+  UInt32 count[17], weight[17], start[18], *p;
+  UInt32 i, k, len, ch, jutbits, avail, nextcode, mask;
+  
+  for (i = 1; i <= 16; i++)
+    count[i] = 0;
+  for (i = 0; (int)i < nchar; i++)
+    count[bitlen[i]]++;
+  
+  start[1] = 0;
+  for (i = 1; i <= 16; i++)
+    start[i + 1] = start[i] + (count[i] << (16 - i));
+  if (start[17] != (UInt32) (1 << 16))
+    throw "Data error";
+  
+  jutbits = 16 - tablebits;
+  for (i = 1; (int)i <= tablebits; i++)
+  {
+    start[i] >>= jutbits;
+    weight[i] = 1 << (tablebits - i);
+  }
+  while (i <= 16)
+  {
+    weight[i] = 1 << (16 - i);
+    i++;
+  }
+  
+  i = start[tablebits + 1] >> jutbits;
+  if (i != (UInt32) (1 << 16))
+  {
+    k = 1 << tablebits;
+    while (i != k)
+      table[i++] = 0;
+  }
+  
+  avail = nchar;
+  mask = 1 << (15 - tablebits);
+  for (ch = 0; (int)ch < nchar; ch++)
+  {
+    if ((len = bitlen[ch]) == 0)
+      continue;
+    k = start[len];
+    nextcode = k + weight[len];
+    if ((int)len <= tablebits)
+    {
+      if (nextcode > (UInt32)tablesize)
+        throw "Data error";
+      for (i = start[len]; i < nextcode; i++)
+        table[i] = ch;
+    }
+    else
+    {
+      p = &table[k >> jutbits];
+      i = len - tablebits;
+      while (i != 0)
+      {
+        if (*p == 0)
+        {
+          right[avail] = left[avail] = 0;
+          *p = avail++;
+        }
+        if (k & mask)
+          p = &right[*p];
+        else
+          p = &left[*p];
+        k <<= 1;
+        i--;
+      }
+      *p = ch;
+    }
+    start[len] = nextcode;
+  }
+}
+
+void CCoder::read_pt_len(int nn, int nbit, int i_special)
+{
+  UInt32 n = m_InBitStream.ReadBits(nbit);
+  if (n == 0)
+  {
+    UInt32 c = m_InBitStream.ReadBits(nbit);
+    int i;
+    for (i = 0; i < nn; i++)
+      pt_len[i] = 0;
+    for (i = 0; i < 256; i++)
+      pt_table[i] = c;
+  }
+  else
+  {
+    UInt32 i = 0;
+    while (i < n)
+    {
+      UInt32 bitBuf = m_InBitStream.GetValue(16);
+      int c = bitBuf >> 13;
+      if (c == 7)
+      {
+        UInt32 mask = 1 << (12);
+        while (mask & bitBuf)
+        {
+          mask >>= 1;
+          c++;
+        }
+      }
+      m_InBitStream.MovePos((c < 7) ? 3 : (int)(c - 3));
+      pt_len[i++] = (Byte)c;
+      if (i == (UInt32)i_special)
+      {
+        c = m_InBitStream.ReadBits(2);
+        while (--c >= 0)
+          pt_len[i++] = 0;
+      }
+    }
+    while (i < (UInt32)nn)
+      pt_len[i++] = 0;
+    MakeTable(nn, pt_len, 8, pt_table, PTABLESIZE);
+  }
+}
+
+void CCoder::read_c_len()
+{
+  int i, c, n;
+  UInt32 mask;
+  
+  n = m_InBitStream.ReadBits(CBIT);
+  if (n == 0)
+  {
+    c = m_InBitStream.ReadBits(CBIT);
+    for (i = 0; i < NC; i++)
+      c_len[i] = 0;
+    for (i = 0; i < CTABLESIZE; i++)
+      c_table[i] = c;
+  }
+  else
+  {
+    i = 0;
+    while (i < n)
+    {
+      UInt32 bitBuf = m_InBitStream.GetValue(16);
+      c = pt_table[bitBuf >> (8)];
+      if (c >= NT)
+      {
+        mask = 1 << (7);
+        do
+        {
+          if (bitBuf & mask)
+            c = right[c];
+          else
+            c = left[c];
+          mask >>= 1;
+        } while (c >= NT);
+      }
+      m_InBitStream.MovePos((int)(pt_len[c]));
+      if (c <= 2)
+      {
+        if (c == 0)
+          c = 1;
+        else if (c == 1)
+          c = m_InBitStream.ReadBits(4) + 3;
+        else
+          c = m_InBitStream.ReadBits(CBIT) + 20;
+        while (--c >= 0)
+          c_len[i++] = 0;
+      }
+      else
+        c_len[i++] = (Byte)(c - 2);
+    }
+    while (i < NC)
+      c_len[i++] = 0;
+    MakeTable(NC, c_len, 12, c_table, CTABLESIZE);
+  }
+}
+
+UInt32 CCoder::decode_c()
+{
+  UInt32 j, mask;
+  UInt32 bitbuf = m_InBitStream.GetValue(16);
+  j = c_table[bitbuf >> 4];
+  if (j >= NC)
+  {
+    mask = 1 << (3);
+    do
+    {
+      if (bitbuf & mask)
+        j = right[j];
+      else
+        j = left[j];
+      mask >>= 1;
+    } while (j >= NC);
+  }
+  m_InBitStream.MovePos((int)(c_len[j]));
+  return j;
+}
+
+UInt32 CCoder::decode_p()
+{
+  UInt32 j, mask;
+  UInt32 bitbuf = m_InBitStream.GetValue(16);
+  j = pt_table[bitbuf >> (8)];
+  if (j >= NP)
+  {
+    mask = 1 << (7);
+    do
+    {
+      if (bitbuf & mask)
+        j = right[j];
+      else
+        j = left[j];
+      mask >>= 1;
+    } while (j >= NP);
+  }
+  m_InBitStream.MovePos((int)(pt_len[j]));
+  if (j != 0)
+  {
+    j--;
+    j = (1 << j) + m_InBitStream.ReadBits((int)j);
+  }
+  return j;
+}
+
+
+HRESULT 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;
+
+  // check it
+  for (int i = 0; i < CTABLESIZE; i++)
+    c_table[i] = 0;
+
+  UInt64 pos = 0;
+  m_OutWindowStream.SetStream(outStream);
+  m_OutWindowStream.Init(false);
+  m_InBitStream.SetStream(inStream);
+  m_InBitStream.Init();
+  
+  CCoderReleaser coderReleaser(this);
+
+  UInt32 blockSize = 0;
+
+  while(pos < *outSize)
+  {
+    if (blockSize == 0)
+    {
+      if (progress != NULL)
+      {
+        UInt64 packSize = m_InBitStream.GetProcessedSize();
+        RINOK(progress->SetRatioInfo(&packSize, &pos));
+      }
+      blockSize = m_InBitStream.ReadBits(16);
+      read_pt_len(NT, TBIT, 3);
+      read_c_len();
+      read_pt_len(NP, PBIT, -1);
+    }
+    blockSize--;
+
+    UInt32 number = decode_c();
+    if (number < 256)
+    {
+      m_OutWindowStream.PutByte((Byte)number);
+      pos++;
+      continue;
+    }
+    else
+    {
+      UInt32 len = number - 256 + kMatchMinLen;
+      UInt32 distance = decode_p();
+      if (distance >= pos)
+        return S_FALSE;
+      m_OutWindowStream.CopyBlock(distance, len);
+        pos += 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; }
+}
+
+}}}