ruby-lzma 0.4.1

data/ext/MyUnknown.h

@@ -0,0 +1,24 @@
+// MyUnknown.h
+
+#ifndef __MYUNKNOWN_H
+#define __MYUNKNOWN_H
+
+#ifdef _WIN32
+
+#ifdef _WIN32_WCE
+#if (_WIN32_WCE > 300)
+#include <basetyps.h>
+#else
+#define MIDL_INTERFACE(x) struct 
+#endif
+#else
+#include <basetyps.h>
+#endif
+
+#include <unknwn.h>
+
+#else 
+#include "MyWindows.h"
+#endif
+  
+#endif

data/ext/MyWindows.h

@@ -0,0 +1,183 @@
+// MyWindows.h
+
+#ifndef __MYWINDOWS_H
+#define __MYWINDOWS_H
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+#else
+
+#include <stddef.h> // for wchar_t
+#include <string.h>
+
+#include "MyGuidDef.h"
+
+typedef char CHAR;
+typedef unsigned char UCHAR;
+typedef unsigned char BYTE;
+
+typedef short SHORT;
+typedef unsigned short USHORT;
+typedef unsigned short WORD;
+typedef short VARIANT_BOOL;
+
+typedef int INT;
+typedef Int32 INT32;
+typedef unsigned int UINT;
+typedef UInt32 UINT32;
+typedef INT32 LONG;   // LONG, ULONG and DWORD must be 32-bit
+typedef UINT32 ULONG;
+typedef UINT32 DWORD;
+
+typedef Int64 LONGLONG;
+typedef UInt64 ULONGLONG;
+
+typedef struct LARGE_INTEGER { LONGLONG QuadPart; }LARGE_INTEGER;
+typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart;} ULARGE_INTEGER;
+
+typedef const CHAR *LPCSTR;
+typedef CHAR TCHAR;
+typedef const TCHAR *LPCTSTR;
+typedef wchar_t WCHAR;
+typedef WCHAR OLECHAR;
+typedef const WCHAR *LPCWSTR;
+typedef OLECHAR *BSTR;
+typedef const OLECHAR *LPCOLESTR;
+typedef OLECHAR *LPOLESTR;
+
+typedef struct _FILETIME
+{
+  DWORD dwLowDateTime;
+  DWORD dwHighDateTime;
+}FILETIME;
+
+#define HRESULT LONG
+#define FAILED(Status) ((HRESULT)(Status)<0)
+typedef ULONG PROPID;
+typedef LONG SCODE;
+
+#define S_OK    ((HRESULT)0x00000000L)
+#define S_FALSE ((HRESULT)0x00000001L)
+#define E_NOINTERFACE ((HRESULT)0x80004002L)
+#define E_ABORT ((HRESULT)0x80004004L)
+#define E_FAIL ((HRESULT)0x80004005L)
+#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)
+#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)
+#define E_INVALIDARG ((HRESULT)0x80070057L)
+
+#ifdef _MSC_VER
+#define STDMETHODCALLTYPE __stdcall 
+#else
+#define STDMETHODCALLTYPE 
+#endif
+
+#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f
+#define STDMETHOD(f) STDMETHOD_(HRESULT, f)
+#define STDMETHODIMP_(type) type STDMETHODCALLTYPE
+#define STDMETHODIMP STDMETHODIMP_(HRESULT)
+
+#define PURE = 0
+
+#define MIDL_INTERFACE(x) struct 
+
+struct IUnknown
+{
+  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;
+  STDMETHOD_(ULONG, AddRef)() PURE;
+  STDMETHOD_(ULONG, Release)() PURE;
+};
+
+typedef IUnknown *LPUNKNOWN;
+
+#define VARIANT_TRUE ((VARIANT_BOOL)-1)
+#define VARIANT_FALSE ((VARIANT_BOOL)0)
+
+enum VARENUM
+{	
+  VT_EMPTY	= 0,
+	VT_NULL	= 1,
+	VT_I2	= 2,
+	VT_I4	= 3,
+	VT_R4	= 4,
+	VT_R8	= 5,
+	VT_CY	= 6,
+	VT_DATE	= 7,
+	VT_BSTR	= 8,
+	VT_DISPATCH	= 9,
+	VT_ERROR	= 10,
+	VT_BOOL	= 11,
+	VT_VARIANT	= 12,
+	VT_UNKNOWN	= 13,
+	VT_DECIMAL	= 14,
+	VT_I1	= 16,
+	VT_UI1	= 17,
+	VT_UI2	= 18,
+	VT_UI4	= 19,
+	VT_I8	= 20,
+	VT_UI8	= 21,
+	VT_INT	= 22,
+	VT_UINT	= 23,
+	VT_VOID	= 24,
+	VT_HRESULT	= 25,
+	VT_FILETIME	= 64
+};
+
+typedef unsigned short VARTYPE;
+typedef WORD PROPVAR_PAD1;
+typedef WORD PROPVAR_PAD2;
+typedef WORD PROPVAR_PAD3;
+
+typedef struct tagPROPVARIANT
+{
+  VARTYPE vt;
+  PROPVAR_PAD1 wReserved1;
+  PROPVAR_PAD2 wReserved2;
+  PROPVAR_PAD3 wReserved3;
+  union 
+  {
+    CHAR cVal;
+    UCHAR bVal;
+    SHORT iVal;
+    USHORT uiVal;
+    LONG lVal;
+    ULONG ulVal;
+    INT intVal;
+    UINT uintVal;
+    LARGE_INTEGER hVal;
+    ULARGE_INTEGER uhVal;
+    VARIANT_BOOL boolVal;
+    SCODE scode;
+    FILETIME filetime;
+    BSTR bstrVal;
+  };
+} PROPVARIANT;
+
+typedef PROPVARIANT tagVARIANT;
+typedef tagVARIANT VARIANT;
+typedef VARIANT VARIANTARG;
+
+MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
+MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
+MY_EXTERN_C void SysFreeString(BSTR bstr);
+MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);
+MY_EXTERN_C UINT SysStringLen(BSTR bstr);
+
+MY_EXTERN_C DWORD GetLastError();
+MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
+MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);
+MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);
+
+#define CP_ACP    0
+#define CP_OEMCP  1
+
+typedef enum tagSTREAM_SEEK
+{	
+  STREAM_SEEK_SET	= 0,
+  STREAM_SEEK_CUR	= 1,
+  STREAM_SEEK_END	= 2
+} STREAM_SEEK;
+
+#endif
+#endif

data/ext/OutBuffer.cpp

@@ -0,0 +1,117 @@
+// OutByte.cpp
+
+#include "StdAfx.h"
+
+#include "OutBuffer.h"
+
+#include "Alloc.h"
+
+bool COutBuffer::Create(UInt32 bufferSize)
+{
+  const UInt32 kMinBlockSize = 1;
+  if (bufferSize < kMinBlockSize)
+    bufferSize = kMinBlockSize;
+  if (_buffer != 0 && _bufferSize == bufferSize)
+    return true;
+  Free();
+  _bufferSize = bufferSize;
+  _buffer = (Byte *)::MidAlloc(bufferSize);
+  return (_buffer != 0);
+}
+
+void COutBuffer::Free()
+{
+  ::MidFree(_buffer);
+  _buffer = 0;
+}
+
+void COutBuffer::SetStream(ISequentialOutStream *stream)
+{
+  _stream = stream;
+}
+
+void COutBuffer::Init()
+{
+  _streamPos = 0;
+  _limitPos = _bufferSize;
+  _pos = 0;
+  _processedSize = 0;
+  _overDict = false;
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = S_OK;
+  #endif
+}
+
+UInt64 COutBuffer::GetProcessedSize() const
+{ 
+  UInt64 res = _processedSize + _pos - _streamPos;
+  if (_streamPos > _pos) 
+    res += _bufferSize;
+  return res;
+}
+
+
+HRESULT COutBuffer::FlushPart()
+{
+  // _streamPos < _bufferSize
+  UInt32 size = (_streamPos >= _pos) ? (_bufferSize - _streamPos) : (_pos - _streamPos);
+  HRESULT result = S_OK;
+  #ifdef _NO_EXCEPTIONS
+  if (ErrorCode != S_OK)
+    result = ErrorCode;
+  #endif
+  if (_buffer2 != 0)
+  {
+    memmove(_buffer2, _buffer + _streamPos, size);
+    _buffer2 += size;
+  }
+
+  if (_stream != 0
+      #ifdef _NO_EXCEPTIONS
+      && (ErrorCode != S_OK)
+      #endif
+     )
+  {
+    UInt32 processedSize = 0;
+    result = _stream->Write(_buffer + _streamPos, size, &processedSize);
+    size = processedSize;
+  }
+  _streamPos += size;
+  if (_streamPos == _bufferSize)
+    _streamPos = 0;
+  if (_pos == _bufferSize)
+  {
+    _overDict = true;
+    _pos = 0;
+  }
+  _limitPos = (_streamPos > _pos) ? _streamPos : _bufferSize;
+  _processedSize += size;
+  return result;
+}
+
+HRESULT COutBuffer::Flush()
+{
+  #ifdef _NO_EXCEPTIONS
+  if (ErrorCode != S_OK)
+    return ErrorCode;
+  #endif
+
+  while(_streamPos != _pos)
+  {
+    HRESULT result = FlushPart();
+    if (result != S_OK)
+      return result;
+  }
+  return S_OK;
+}
+
+void COutBuffer::FlushWithCheck()
+{
+  HRESULT result = FlushPart();
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = result;
+  #else
+  if (result != S_OK)
+    throw COutBufferException(result);
+  #endif
+}

data/ext/OutBuffer.h

@@ -0,0 +1,64 @@
+// OutBuffer.h
+
+#ifndef __OUTBUFFER_H
+#define __OUTBUFFER_H
+
+#include "IStream.h"
+#include "MyCom.h"
+
+#ifndef _NO_EXCEPTIONS
+struct COutBufferException
+{
+  HRESULT ErrorCode;
+  COutBufferException(HRESULT errorCode): ErrorCode(errorCode) {}
+};
+#endif
+
+class COutBuffer
+{
+protected:
+  Byte *_buffer;
+  UInt32 _pos;
+  UInt32 _limitPos;
+  UInt32 _streamPos;
+  UInt32 _bufferSize;
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt64 _processedSize;
+  Byte  *_buffer2;
+  bool _overDict;
+
+  HRESULT FlushPart();
+  void FlushWithCheck();
+public:
+  #ifdef _NO_EXCEPTIONS
+  HRESULT ErrorCode;
+  #endif
+
+  COutBuffer(): _buffer(0), _pos(0), _stream(0), _buffer2(0) {}
+  ~COutBuffer() { Free(); }
+  
+  bool Create(UInt32 bufferSize);
+  void Free();
+
+  void SetMemStream(Byte *buffer) { _buffer2 = buffer; }
+  void SetStream(ISequentialOutStream *stream);
+  void Init();
+  HRESULT Flush();
+  void ReleaseStream() {  _stream.Release(); }
+
+  void WriteByte(Byte b)
+  {
+    _buffer[_pos++] = b;
+    if(_pos == _limitPos)
+      FlushWithCheck();
+  }
+  void WriteBytes(const void *data, size_t size)
+  {
+    for (size_t i = 0; i < size; i++)
+      WriteByte(((const Byte *)data)[i]);
+  }
+
+  UInt64 GetProcessedSize() const;
+};
+
+#endif

data/ext/Pat.h

@@ -0,0 +1,318 @@
+// Pat.h
+
+// #ifndef __PATRICIA__H
+// #define __PATRICIA__H
+
+#include "MyCom.h"
+#include "Types.h"
+#include "LZInWindow.h"
+
+namespace PAT_NAMESPACE {
+
+struct CNode;
+
+typedef CNode *CNodePointer;
+
+// #define __AUTO_REMOVE
+
+// #define __NODE_4_BITS
+// #define __NODE_3_BITS
+// #define __NODE_2_BITS
+// #define __NODE_2_BITS_PADDING
+
+// #define __HASH_3
+
+
+typedef UInt32 CIndex;
+
+#ifdef __NODE_4_BITS
+  typedef UInt32 CIndex2;
+  typedef UInt32 CSameBitsType;
+#else
+#ifdef __NODE_3_BITS
+  typedef UInt32 CIndex2;
+  typedef UInt32 CSameBitsType;
+#else
+
+  typedef UInt32 CIndex;
+  typedef UInt32 CSameBitsType;
+
+  typedef CIndex CIndex2;
+#endif
+#endif
+
+const UInt32 kNumBitsInIndex = sizeof(CIndex) * 8;
+const UInt32 kMatchStartValue = UInt32(1) << (kNumBitsInIndex - 1);
+// don't change kMatchStartValue definition, since it is used in 
+// PatMain.h: 
+
+typedef CIndex CMatchPointer;
+
+const UInt32 kDescendantEmptyValue = kMatchStartValue - 1;
+
+union CDescendant 
+{
+  CIndex NodePointer;
+  CMatchPointer MatchPointer;
+  bool IsEmpty() const { return NodePointer == kDescendantEmptyValue; }
+  bool IsNode() const { return NodePointer < kDescendantEmptyValue; }
+  bool IsMatch() const { return NodePointer > kDescendantEmptyValue; }
+  void MakeEmpty() { NodePointer = kDescendantEmptyValue; }
+};
+
+#undef MY_BYTE_SIZE
+
+#ifdef __NODE_4_BITS
+  #define MY_BYTE_SIZE 8
+  const UInt32 kNumSubBits = 4;
+#else
+#ifdef __NODE_3_BITS
+  #define MY_BYTE_SIZE 9
+  const UInt32 kNumSubBits = 3;
+#else
+  #define MY_BYTE_SIZE 8
+  #ifdef __NODE_2_BITS
+    const UInt32 kNumSubBits = 2;
+  #else
+    const UInt32 kNumSubBits = 1;
+  #endif
+#endif
+#endif
+
+const UInt32 kNumSubNodes = 1 << kNumSubBits;
+const UInt32 kSubNodesMask = kNumSubNodes - 1;
+
+struct CNode
+{
+  CIndex2 LastMatch;
+  CSameBitsType NumSameBits;
+  union
+  {
+    CDescendant  Descendants[kNumSubNodes];
+    UInt32 NextFreeNode;
+  };
+  #ifdef __NODE_2_BITS
+  #ifdef __NODE_2_BITS_PADDING
+  UInt32 Padding[2];
+  #endif
+  #endif
+};
+
+#undef kIDNumBitsByte
+#undef kIDNumBitsString
+
+#ifdef __NODE_4_BITS
+  #define kIDNumBitsByte 0x30
+  #define kIDNumBitsString TEXT("4")
+#else
+#ifdef __NODE_3_BITS
+  #define kIDNumBitsByte 0x20
+  #define kIDNumBitsString TEXT("3")
+#else
+#ifdef __NODE_2_BITS
+  #define kIDNumBitsByte 0x10
+  #define kIDNumBitsString TEXT("2")
+#else
+  #define kIDNumBitsByte 0x00
+  #define kIDNumBitsString TEXT("1")
+#endif
+#endif
+#endif
+
+#undef kIDManualRemoveByte
+#undef kIDManualRemoveString
+
+#ifdef __AUTO_REMOVE
+  #define kIDManualRemoveByte 0x00
+  #define kIDManualRemoveString TEXT("")
+#else
+  #define kIDManualRemoveByte 0x08
+  #define kIDManualRemoveString TEXT("R")
+#endif
+
+#undef kIDHash3Byte
+#undef kIDHash3String
+
+#ifdef __HASH_3
+  #define kIDHash3Byte 0x04
+  #define kIDHash3String TEXT("H")
+#else
+  #define kIDHash3Byte 0x00
+  #define kIDHash3String TEXT("")
+#endif
+
+#undef kIDUse3BytesByte
+#undef kIDUse3BytesString
+
+#define kIDUse3BytesByte 0x00
+#define kIDUse3BytesString TEXT("")
+
+#undef kIDPaddingByte
+#undef kIDPaddingString
+
+#ifdef __NODE_2_BITS_PADDING
+  #define kIDPaddingByte 0x01
+  #define kIDPaddingString TEXT("P")
+#else
+  #define kIDPaddingByte 0x00
+  #define kIDPaddingString TEXT("")
+#endif
+
+
+// #undef kIDString
+// #define kIDString TEXT("Compress.MatchFinderPat") kIDNumBitsString kIDManualRemoveString kIDUse3BytesString kIDPaddingString kIDHash3String
+
+// {23170F69-40C1-278C-01XX-0000000000}
+
+DEFINE_GUID(PAT_CLSID, 
+0x23170F69, 0x40C1, 0x278C, 0x01, 
+kIDNumBitsByte | 
+kIDManualRemoveByte | kIDHash3Byte | kIDUse3BytesByte | kIDPaddingByte, 
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+
+// III(PAT_NAMESPACE)
+
+class CPatricia: 
+  public IMatchFinder,
+  public IMatchFinderSetCallback,
+  public CMyUnknownImp,
+  CLZInWindow
+{ 
+  MY_UNKNOWN_IMP1(IMatchFinderSetCallback)
+
+  STDMETHOD(Init)(ISequentialInStream *aStream);
+  STDMETHOD_(void, ReleaseStream)();
+  STDMETHOD(MovePos)();
+  STDMETHOD_(Byte, GetIndexByte)(Int32 index);
+  STDMETHOD_(UInt32, GetMatchLen)(Int32 index, UInt32 back, UInt32 limit);
+  STDMETHOD_(UInt32, GetNumAvailableBytes)();
+  STDMETHOD(Create)(UInt32 historySize, 
+      UInt32 keepAddBufferBefore, UInt32 matchMaxLen, 
+      UInt32 keepAddBufferAfter);
+  STDMETHOD_(UInt32, GetLongestMatch)(UInt32 *distances);
+  STDMETHOD_(void, DummyLongestMatch)();
+  STDMETHOD_(const Byte *, GetPointerToCurrentPos)();
+
+  void FreeMemory();
+public:
+  CPatricia();
+  ~CPatricia();
+
+  UInt32 _sizeHistory;
+  UInt32 _matchMaxLen;
+
+  CDescendant *m_HashDescendants;
+  #ifdef __HASH_3
+  CDescendant *m_Hash2Descendants;
+  #endif
+
+  CNode *m_Nodes;
+
+  UInt32 m_FreeNode;
+  UInt32 m_FreeNodeMax;
+
+  #ifdef __AUTO_REMOVE
+  UInt32 m_NumUsedNodes;
+  UInt32 m_NumNodes;
+  #else
+  bool  m_SpecialRemoveMode;
+  #endif
+
+  bool  m_SpecialMode;
+  UInt32 m_NumNotChangedCycles;
+  UInt32 *m_TmpBacks;
+
+  CMyComPtr<IMatchFinderCallback> m_Callback;
+
+  virtual void BeforeMoveBlock();
+  virtual void AfterMoveBlock();
+
+  // IMatchFinderSetCallback
+  STDMETHOD(SetCallback)(IMatchFinderCallback *callback);
+
+  void ChangeLastMatch(UInt32 hashValue);
+  
+  #ifdef __AUTO_REMOVE
+  void TestRemoveDescendant(CDescendant &descendant, UInt32 limitPos);
+  void TestRemoveNodes();
+  void RemoveNode(UInt32 index);
+  void TestRemoveAndNormalizeDescendant(CDescendant &descendant, 
+      UInt32 limitPos, UInt32 subValue);
+  void TestRemoveNodesAndNormalize();
+  #else
+  void NormalizeDescendant(CDescendant &descendant, UInt32 subValue);
+  void Normalize();
+  void RemoveMatch();
+  #endif
+private:
+  void AddInternalNode(CNodePointer aNode, CIndex *aNodePointerPointer, 
+      Byte aByte, Byte aByteXOR, UInt32 aNumSameBits, UInt32 aPos)
+  {
+    while((aByteXOR & kSubNodesMask) == 0)
+    {
+      aByteXOR >>= kNumSubBits;
+      aByte >>= kNumSubBits;
+      aNumSameBits -= kNumSubBits;
+    }
+    // Insert New Node
+    CNodePointer aNewNode = &m_Nodes[m_FreeNode];
+    UInt32 aNodeIndex = *aNodePointerPointer;
+    *aNodePointerPointer = m_FreeNode;
+    m_FreeNode = aNewNode->NextFreeNode;
+    #ifdef __AUTO_REMOVE
+    m_NumUsedNodes++;
+    #endif
+    if (m_FreeNode > m_FreeNodeMax)
+    {
+      m_FreeNodeMax = m_FreeNode;
+      m_Nodes[m_FreeNode].NextFreeNode = m_FreeNode + 1;
+    }
+
+    UInt32 aBitsNew = aByte & kSubNodesMask;
+    UInt32 aBitsOld = (aByte ^ aByteXOR) & kSubNodesMask;
+    for (UInt32 i = 0; i < kNumSubNodes; i++)
+      aNewNode->Descendants[i].NodePointer = kDescendantEmptyValue;
+    aNewNode->Descendants[aBitsNew].MatchPointer = aPos + kMatchStartValue;
+    aNewNode->Descendants[aBitsOld].NodePointer = aNodeIndex;
+    aNewNode->NumSameBits = CSameBitsType(aNode->NumSameBits - aNumSameBits);
+    aNewNode->LastMatch = aPos;
+    
+    aNode->NumSameBits = CSameBitsType(aNumSameBits - kNumSubBits);
+  }
+
+  void AddLeafNode(CNodePointer aNode, Byte aByte, Byte aByteXOR, 
+      UInt32 aNumSameBits, UInt32 aPos, UInt32 aDescendantIndex)
+  {
+    for(;(aByteXOR & kSubNodesMask) == 0; aNumSameBits += kNumSubBits)
+    {
+      aByte >>= kNumSubBits;
+      aByteXOR >>= kNumSubBits;
+    }
+    UInt32 aNewNodeIndex = m_FreeNode;
+    CNodePointer aNewNode = &m_Nodes[m_FreeNode];
+    m_FreeNode = aNewNode->NextFreeNode;
+    #ifdef __AUTO_REMOVE
+    m_NumUsedNodes++;
+    #endif
+    if (m_FreeNode > m_FreeNodeMax)
+    {
+      m_FreeNodeMax = m_FreeNode;
+      m_Nodes[m_FreeNode].NextFreeNode = m_FreeNode + 1;
+    }
+
+    UInt32 aBitsNew = (aByte & kSubNodesMask);
+    UInt32 aBitsOld = (aByte ^ aByteXOR) & kSubNodesMask;
+    for (UInt32 i = 0; i < kNumSubNodes; i++)
+      aNewNode->Descendants[i].NodePointer = kDescendantEmptyValue;
+    aNewNode->Descendants[aBitsNew].MatchPointer = aPos + kMatchStartValue;
+    aNewNode->Descendants[aBitsOld].MatchPointer = 
+      aNode->Descendants[aDescendantIndex].MatchPointer;
+    aNewNode->NumSameBits = CSameBitsType(aNumSameBits);
+    aNewNode->LastMatch = aPos;
+    aNode->Descendants[aDescendantIndex].NodePointer = aNewNodeIndex;
+  }
+};
+
+}
+
+// #endif