seven_zip_ruby 1.0.0

data/ext/p7zip/CPP/7zip/CMAKE/generate.sh

@@ -0,0 +1,37 @@
+
+doit()
+{
+	cd ..
+	rm -fr "$3.$1"
+	mkdir "$3.$1"
+	cd "$3.$1"
+	cp ../CMAKE/$4 CMakeLists.txt
+	
+	mkdir 7za 7zFM 7zG Format7zFree
+	
+	cp ../CMAKE/CMakeLists_7za.txt  7za/CMakeLists.txt
+	
+	cp ../CMAKE/CMakeLists_7zFM.txt 7zFM/CMakeLists.txt
+	
+	cp ../CMAKE/CMakeLists_7zG.txt 7zG/CMakeLists.txt
+	
+	cp ../CMAKE/CMakeLists_Format7zFree.txt Format7zFree/CMakeLists.txt
+	
+	
+	cmake -G "$2" -DCMAKE_BUILD_TYPE=Debug 
+	#cmake -G "$2" -DCMAKE_BUILD_TYPE=Release 
+}
+
+CURDIR=$PWD
+
+cd $CURDIR
+doit "Unix" "Unix Makefiles"  "P7ZIP" "CMakeLists_ALL.txt"
+
+cd $CURDIR
+doit "codeblocks" "CodeBlocks - Unix Makefiles"  "P7ZIP" "CMakeLists_ALL.txt"
+
+cd $CURDIR
+doit "KDevelop3" "KDevelop3"  "P7ZIP" "CMakeLists_ALL.txt"
+
+cd $CURDIR
+doit "EclipseCDT4" "Eclipse CDT4 - Unix Makefiles"  "P7ZIP" "CMakeLists_ALL.txt"

data/ext/p7zip/CPP/7zip/CMAKE/generate_xcode.sh

@@ -0,0 +1,32 @@
+
+doit()
+{
+	cd ..
+	rm -fr "$3.$1"
+	mkdir "$3.$1"
+	cd "$3.$1"
+	cp ../CMAKE/$4 CMakeLists.txt
+	
+	mkdir 7za 7zFM 7zG Format7zFree
+	
+	cp ../CMAKE/CMakeLists_7za.txt  7za/CMakeLists.txt
+	
+	cp ../CMAKE/CMakeLists_7zFM.txt 7zFM/CMakeLists.txt
+	
+	cp ../CMAKE/CMakeLists_7zG.txt 7zG/CMakeLists.txt
+	
+	cp ../CMAKE/CMakeLists_Format7zFree.txt Format7zFree/CMakeLists.txt
+	
+	
+	cmake -G "$2" -DCMAKE_BUILD_TYPE=Debug 
+	#cmake -G "$2" -DCMAKE_BUILD_TYPE=Release 
+}
+
+
+CMAKE_OSX_ARCHITECTURES=i386
+export CMAKE_OSX_ARCHITECTURES
+
+CURDIR=$PWD
+
+ cd $CURDIR
+ doit "Xcode" "Xcode" "P7ZIP" "CMakeLists_ALL.txt"

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

@@ -0,0 +1,226 @@
+// CWrappers.h
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "CWrappers.h"
+
+#include "StreamUtils.h"
+
+#define PROGRESS_UNKNOWN_VALUE ((UInt64)(Int64)-1)
+
+#define CONVERT_PR_VAL(x) (x == PROGRESS_UNKNOWN_VALUE ? NULL : &x)
+
+static SRes CompressProgress(void *pp, UInt64 inSize, UInt64 outSize)
+{
+  CCompressProgressWrap *p = (CCompressProgressWrap *)pp;
+  p->Res = p->Progress->SetRatioInfo(CONVERT_PR_VAL(inSize), CONVERT_PR_VAL(outSize));
+  return (SRes)p->Res;
+}
+
+CCompressProgressWrap::CCompressProgressWrap(ICompressProgressInfo *progress)
+{
+  p.Progress = CompressProgress;
+  Progress = progress;
+  Res = SZ_OK;
+}
+
+static const UInt32 kStreamStepSize = (UInt32)1 << 31;
+
+SRes HRESULT_To_SRes(HRESULT res, SRes defaultRes)
+{
+  switch(res)
+  {
+    case S_OK: return SZ_OK;
+    case E_OUTOFMEMORY: return SZ_ERROR_MEM;
+    case E_INVALIDARG: return SZ_ERROR_PARAM;
+    case E_ABORT: return SZ_ERROR_PROGRESS;
+    case S_FALSE: return SZ_ERROR_DATA;
+  }
+  return defaultRes;
+}
+
+static SRes MyRead(void *object, void *data, size_t *size)
+{
+  CSeqInStreamWrap *p = (CSeqInStreamWrap *)object;
+  UInt32 curSize = ((*size < kStreamStepSize) ? (UInt32)*size : kStreamStepSize);
+  p->Res = (p->Stream->Read(data, curSize, &curSize));
+  *size = curSize;
+  if (p->Res == S_OK)
+    return SZ_OK;
+  return HRESULT_To_SRes(p->Res, SZ_ERROR_READ);
+}
+
+static size_t MyWrite(void *object, const void *data, size_t size)
+{
+  CSeqOutStreamWrap *p = (CSeqOutStreamWrap *)object;
+  if (p->Stream)
+  {
+    p->Res = WriteStream(p->Stream, data, size);
+    if (p->Res != 0)
+      return 0;
+  }
+  else
+    p->Res = S_OK;
+  p->Processed += size;
+  return size;
+}
+
+CSeqInStreamWrap::CSeqInStreamWrap(ISequentialInStream *stream)
+{
+  p.Read = MyRead;
+  Stream = stream;
+}
+
+CSeqOutStreamWrap::CSeqOutStreamWrap(ISequentialOutStream *stream)
+{
+  p.Write = MyWrite;
+  Stream = stream;
+  Res = SZ_OK;
+  Processed = 0;
+}
+
+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;
+}
+
+static SRes InStreamWrap_Read(void *pp, void *data, size_t *size)
+{
+  CSeekInStreamWrap *p = (CSeekInStreamWrap *)pp;
+  UInt32 curSize = ((*size < kStreamStepSize) ? (UInt32)*size : kStreamStepSize);
+  p->Res = p->Stream->Read(data, curSize, &curSize);
+  *size = curSize;
+  return (p->Res == S_OK) ? SZ_OK : SZ_ERROR_READ;
+}
+
+static SRes InStreamWrap_Seek(void *pp, Int64 *offset, ESzSeek origin)
+{
+  CSeekInStreamWrap *p = (CSeekInStreamWrap *)pp;
+  UInt32 moveMethod;
+  switch(origin)
+  {
+    case SZ_SEEK_SET: moveMethod = STREAM_SEEK_SET; break;
+    case SZ_SEEK_CUR: moveMethod = STREAM_SEEK_CUR; break;
+    case SZ_SEEK_END: moveMethod = STREAM_SEEK_END; break;
+    default: return SZ_ERROR_PARAM;
+  }
+  UInt64 newPosition;
+  p->Res = p->Stream->Seek(*offset, moveMethod, &newPosition);
+  *offset = (Int64)newPosition;
+  return (p->Res == S_OK) ? SZ_OK : SZ_ERROR_READ;
+}
+
+CSeekInStreamWrap::CSeekInStreamWrap(IInStream *stream)
+{
+  Stream = stream;
+  p.Read = InStreamWrap_Read;
+  p.Seek = InStreamWrap_Seek;
+  Res = S_OK;
+}
+
+
+/* ---------- CByteInBufWrap ---------- */
+
+void CByteInBufWrap::Free()
+{
+  ::MidFree(Buf);
+  Buf = 0;
+}
+
+bool CByteInBufWrap::Alloc(UInt32 size)
+{
+  if (Buf == 0 || size != Size)
+  {
+    Free();
+    Lim = Cur = Buf = (Byte *)::MidAlloc((size_t)size);
+    Size = size;
+  }
+  return (Buf != 0);
+}
+
+Byte CByteInBufWrap::ReadByteFromNewBlock()
+{
+  if (Res == S_OK)
+  {
+    UInt32 avail;
+    Processed += (Cur - Buf);
+    Res = Stream->Read(Buf, Size, &avail);
+    Cur = Buf;
+    Lim = Buf + avail;
+    if (avail != 0)
+      return *Cur++;
+  }
+  Extra = true;
+  return 0;
+}
+
+static Byte Wrap_ReadByte(void *pp)
+{
+  CByteInBufWrap *p = (CByteInBufWrap *)pp;
+  if (p->Cur != p->Lim)
+    return *p->Cur++;
+  return p->ReadByteFromNewBlock();
+}
+
+CByteInBufWrap::CByteInBufWrap(): Buf(0)
+{
+  p.Read = Wrap_ReadByte;
+}
+
+
+/* ---------- CByteOutBufWrap ---------- */
+
+void CByteOutBufWrap::Free()
+{
+  ::MidFree(Buf);
+  Buf = 0;
+}
+
+bool CByteOutBufWrap::Alloc(size_t size)
+{
+  if (Buf == 0 || size != Size)
+  {
+    Free();
+    Buf = (Byte *)::MidAlloc(size);
+    Size = size;
+  }
+  return (Buf != 0);
+}
+
+HRESULT CByteOutBufWrap::Flush()
+{
+  if (Res == S_OK)
+  {
+    size_t size = (Cur - Buf);
+    Res = WriteStream(Stream, Buf, size);
+    if (Res == S_OK)
+      Processed += size;
+    Cur = Buf;
+  }
+  return Res;
+}
+
+static void Wrap_WriteByte(void *pp, Byte b)
+{
+  CByteOutBufWrap *p = (CByteOutBufWrap *)pp;
+  Byte *dest = p->Cur;
+  *dest = b;
+  p->Cur = ++dest;
+  if (dest == p->Lim)
+    p->Flush();
+}
+
+CByteOutBufWrap::CByteOutBufWrap(): Buf(0)
+{
+  p.Write = Wrap_WriteByte;
+}

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

@@ -0,0 +1,109 @@
+// CWrappers.h
+
+#ifndef __C_WRAPPERS_H
+#define __C_WRAPPERS_H
+
+#include "../ICoder.h"
+#include "../../Common/MyCom.h"
+
+struct CCompressProgressWrap
+{
+  ICompressProgress p;
+  ICompressProgressInfo *Progress;
+  HRESULT Res;
+  CCompressProgressWrap(ICompressProgressInfo *progress);
+};
+
+struct CSeqInStreamWrap
+{
+  ISeqInStream p;
+  ISequentialInStream *Stream;
+  HRESULT Res;
+  CSeqInStreamWrap(ISequentialInStream *stream);
+};
+
+struct CSeekInStreamWrap
+{
+  ISeekInStream p;
+  IInStream *Stream;
+  HRESULT Res;
+  CSeekInStreamWrap(IInStream *stream);
+};
+
+struct CSeqOutStreamWrap
+{
+  ISeqOutStream p;
+  ISequentialOutStream *Stream;
+  HRESULT Res;
+  UInt64 Processed;
+  CSeqOutStreamWrap(ISequentialOutStream *stream);
+};
+
+HRESULT SResToHRESULT(SRes res);
+
+struct CByteInBufWrap
+{
+  IByteIn p;
+  const Byte *Cur;
+  const Byte *Lim;
+  Byte *Buf;
+  UInt32 Size;
+  ISequentialInStream *Stream;
+  UInt64 Processed;
+  bool Extra;
+  HRESULT Res;
+  
+  CByteInBufWrap();
+  ~CByteInBufWrap() { Free();  }
+  void Free();
+  bool Alloc(UInt32 size);
+  void Init()
+  {
+    Lim = Cur = Buf;
+    Processed = 0;
+    Extra = false;
+    Res = S_OK;
+  }
+  UInt64 GetProcessed() const { return Processed + (Cur - Buf); }
+  Byte ReadByteFromNewBlock();
+  Byte ReadByte()
+  {
+    if (Cur != Lim)
+      return *Cur++;
+    return ReadByteFromNewBlock();
+  }
+};
+
+struct CByteOutBufWrap
+{
+  IByteOut p;
+  Byte *Cur;
+  const Byte *Lim;
+  Byte *Buf;
+  size_t Size;
+  ISequentialOutStream *Stream;
+  UInt64 Processed;
+  HRESULT Res;
+  
+  CByteOutBufWrap();
+  ~CByteOutBufWrap() { Free();  }
+  void Free();
+  bool Alloc(size_t size);
+  void Init()
+  {
+    Cur = Buf;
+    Lim = Buf + Size;
+    Processed = 0;
+    Res = S_OK;
+  }
+  UInt64 GetProcessed() const { return Processed + (Cur - Buf); }
+  HRESULT Flush();
+  void WriteByte(Byte b)
+  {
+    *Cur++ = b;
+    if (Cur == Lim)
+      Flush();
+  }
+};
+
+#endif

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

@@ -0,0 +1,293 @@
+// CreateCoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../Windows/Defs.h"
+#include "../../Windows/PropVariant.h"
+
+#include "CreateCoder.h"
+
+#include "FilterCoder.h"
+#include "RegisterCodec.h"
+
+static const unsigned int kNumCodecsMax = 64;
+unsigned int g_NumCodecs = 0;
+const CCodecInfo *g_Codecs[kNumCodecsMax];
+void RegisterCodec(const CCodecInfo *codecInfo)
+{
+  if (g_NumCodecs < kNumCodecsMax)
+    g_Codecs[g_NumCodecs++] = codecInfo;
+}
+
+#ifdef EXTERNAL_CODECS
+static HRESULT ReadNumberOfStreams(ICompressCodecsInfo *codecsInfo, UInt32 index, PROPID propID, UInt32 &res)
+{
+  NWindows::NCOM::CPropVariant prop;
+  RINOK(codecsInfo->GetProperty(index, propID, &prop));
+  if (prop.vt == VT_EMPTY)
+    res = 1;
+  else if (prop.vt == VT_UI4)
+    res = prop.ulVal;
+  else
+    return E_INVALIDARG;
+  return S_OK;
+}
+
+static HRESULT ReadIsAssignedProp(ICompressCodecsInfo *codecsInfo, UInt32 index, PROPID propID, bool &res)
+{
+  NWindows::NCOM::CPropVariant prop;
+  RINOK(codecsInfo->GetProperty(index, propID, &prop));
+  if (prop.vt == VT_EMPTY)
+    res = true;
+  else if (prop.vt == VT_BOOL)
+    res = VARIANT_BOOLToBool(prop.boolVal);
+  else
+    return E_INVALIDARG;
+  return S_OK;
+}
+
+HRESULT LoadExternalCodecs(ICompressCodecsInfo *codecsInfo, CObjectVector<CCodecInfoEx> &externalCodecs)
+{
+  UInt32 num;
+  RINOK(codecsInfo->GetNumberOfMethods(&num));
+  for (UInt32 i = 0; i < num; i++)
+  {
+    CCodecInfoEx info;
+    NWindows::NCOM::CPropVariant prop;
+    RINOK(codecsInfo->GetProperty(i, NMethodPropID::kID, &prop));
+    // if (prop.vt != VT_BSTR)
+    // info.Id.IDSize = (Byte)SysStringByteLen(prop.bstrVal);
+    // memmove(info.Id.ID, prop.bstrVal, info.Id.IDSize);
+    if (prop.vt != VT_UI8)
+    {
+      continue; // old Interface
+      // return E_INVALIDARG;
+    }
+    info.Id = prop.uhVal.QuadPart;
+    prop.Clear();
+    
+    RINOK(codecsInfo->GetProperty(i, NMethodPropID::kName, &prop));
+    if (prop.vt == VT_BSTR)
+      info.Name = prop.bstrVal;
+    else if (prop.vt != VT_EMPTY)
+      return E_INVALIDARG;;
+    
+    RINOK(ReadNumberOfStreams(codecsInfo, i, NMethodPropID::kInStreams, info.NumInStreams));
+    RINOK(ReadNumberOfStreams(codecsInfo, i, NMethodPropID::kOutStreams, info.NumOutStreams));
+    RINOK(ReadIsAssignedProp(codecsInfo, i, NMethodPropID::kEncoderIsAssigned, info.EncoderIsAssigned));
+    RINOK(ReadIsAssignedProp(codecsInfo, i, NMethodPropID::kDecoderIsAssigned, info.DecoderIsAssigned));
+    
+    externalCodecs.Add(info);
+  }
+  return S_OK;
+}
+
+#endif
+
+bool FindMethod(
+  #ifdef EXTERNAL_CODECS
+  ICompressCodecsInfo * /* codecsInfo */, const CObjectVector<CCodecInfoEx> *externalCodecs,
+  #endif
+  const UString &name,
+  CMethodId &methodId, UInt32 &numInStreams, UInt32 &numOutStreams)
+{
+  UInt32 i;
+  for (i = 0; i < g_NumCodecs; i++)
+  {
+    const CCodecInfo &codec = *g_Codecs[i];
+    if (name.CompareNoCase(codec.Name) == 0)
+    {
+      methodId = codec.Id;
+      numInStreams = codec.NumInStreams;
+      numOutStreams = 1;
+      return true;
+    }
+  }
+  #ifdef EXTERNAL_CODECS
+  if (externalCodecs)
+    for (i = 0; i < (UInt32)externalCodecs->Size(); i++)
+    {
+      const CCodecInfoEx &codec = (*externalCodecs)[i];
+      if (codec.Name.CompareNoCase(name) == 0)
+      {
+        methodId = codec.Id;
+        numInStreams = codec.NumInStreams;
+        numOutStreams = codec.NumOutStreams;
+        return true;
+      }
+    }
+  #endif
+  return false;
+}
+
+bool FindMethod(
+  #ifdef EXTERNAL_CODECS
+  ICompressCodecsInfo * /* codecsInfo */, const CObjectVector<CCodecInfoEx> *externalCodecs,
+  #endif
+  CMethodId methodId, UString &name)
+{
+  UInt32 i;
+  for (i = 0; i < g_NumCodecs; i++)
+  {
+    const CCodecInfo &codec = *g_Codecs[i];
+    if (methodId == codec.Id)
+    {
+      name = codec.Name;
+      return true;
+    }
+  }
+  #ifdef EXTERNAL_CODECS
+  if (externalCodecs)
+    for (i = 0; i < (UInt32)externalCodecs->Size(); i++)
+    {
+      const CCodecInfoEx &codec = (*externalCodecs)[i];
+      if (methodId == codec.Id)
+      {
+        name = codec.Name;
+        return true;
+      }
+    }
+  #endif
+  return false;
+}
+
+HRESULT CreateCoder(
+  DECL_EXTERNAL_CODECS_LOC_VARS
+  CMethodId methodId,
+  CMyComPtr<ICompressFilter> &filter,
+  CMyComPtr<ICompressCoder> &coder,
+  CMyComPtr<ICompressCoder2> &coder2,
+  bool encode, bool onlyCoder)
+{
+  bool created = false;
+  UInt32 i;
+  for (i = 0; i < g_NumCodecs; i++)
+  {
+    const CCodecInfo &codec = *g_Codecs[i];
+    if (codec.Id == methodId)
+    {
+      if (encode)
+      {
+        if (codec.CreateEncoder)
+        {
+          void *p = codec.CreateEncoder();
+          if (codec.IsFilter) filter = (ICompressFilter *)p;
+          else if (codec.NumInStreams == 1) coder = (ICompressCoder *)p;
+          else coder2 = (ICompressCoder2 *)p;
+          created = (p != 0);
+          break;
+        }
+      }
+      else
+        if (codec.CreateDecoder)
+        {
+          void *p = codec.CreateDecoder();
+          if (codec.IsFilter) filter = (ICompressFilter *)p;
+          else if (codec.NumInStreams == 1) coder = (ICompressCoder *)p;
+          else coder2 = (ICompressCoder2 *)p;
+          created = (p != 0);
+          break;
+        }
+    }
+  }
+
+  #ifdef EXTERNAL_CODECS
+  if (!created && externalCodecs)
+    for (i = 0; i < (UInt32)externalCodecs->Size(); i++)
+    {
+      const CCodecInfoEx &codec = (*externalCodecs)[i];
+      if (codec.Id == methodId)
+      {
+        if (encode)
+        {
+          if (codec.EncoderIsAssigned)
+          {
+            if (codec.IsSimpleCodec())
+            {
+              HRESULT result = codecsInfo->CreateEncoder(i, &IID_ICompressCoder, (void **)&coder);
+              if (result != S_OK && result != E_NOINTERFACE && result != CLASS_E_CLASSNOTAVAILABLE)
+                return result;
+              if (!coder)
+              {
+                RINOK(codecsInfo->CreateEncoder(i, &IID_ICompressFilter, (void **)&filter));
+              }
+            }
+            else
+            {
+              RINOK(codecsInfo->CreateEncoder(i, &IID_ICompressCoder2, (void **)&coder2));
+            }
+            break;
+          }
+        }
+        else
+          if (codec.DecoderIsAssigned)
+          {
+            if (codec.IsSimpleCodec())
+            {
+              HRESULT result = codecsInfo->CreateDecoder(i, &IID_ICompressCoder, (void **)&coder);
+              if (result != S_OK && result != E_NOINTERFACE && result != CLASS_E_CLASSNOTAVAILABLE)
+                return result;
+              if (!coder)
+              {
+                RINOK(codecsInfo->CreateDecoder(i, &IID_ICompressFilter, (void **)&filter));
+              }
+            }
+            else
+            {
+              RINOK(codecsInfo->CreateDecoder(i, &IID_ICompressCoder2, (void **)&coder2));
+            }
+            break;
+          }
+      }
+    }
+  #endif
+
+  if (onlyCoder && filter)
+  {
+    CFilterCoder *coderSpec = new CFilterCoder;
+    coder = coderSpec;
+    coderSpec->Filter = filter;
+  }
+  return S_OK;
+}
+
+HRESULT CreateCoder(
+  DECL_EXTERNAL_CODECS_LOC_VARS
+  CMethodId methodId,
+  CMyComPtr<ICompressCoder> &coder,
+  CMyComPtr<ICompressCoder2> &coder2,
+  bool encode)
+{
+  CMyComPtr<ICompressFilter> filter;
+  return CreateCoder(
+    EXTERNAL_CODECS_LOC_VARS
+    methodId,
+    filter, coder, coder2, encode, true);
+}
+
+HRESULT CreateCoder(
+  DECL_EXTERNAL_CODECS_LOC_VARS
+  CMethodId methodId,
+  CMyComPtr<ICompressCoder> &coder, bool encode)
+{
+  CMyComPtr<ICompressFilter> filter;
+  CMyComPtr<ICompressCoder2> coder2;
+  return CreateCoder(
+    EXTERNAL_CODECS_LOC_VARS
+    methodId,
+    coder, coder2, encode);
+}
+
+HRESULT CreateFilter(
+  DECL_EXTERNAL_CODECS_LOC_VARS
+  CMethodId methodId,
+  CMyComPtr<ICompressFilter> &filter,
+  bool encode)
+{
+  CMyComPtr<ICompressCoder> coder;
+  CMyComPtr<ICompressCoder2> coder2;
+  return CreateCoder(
+    EXTERNAL_CODECS_LOC_VARS
+    methodId,
+    filter, coder, coder2, encode, false);
+}