seven_zip_ruby_am 1.2.5.1

data/ext/p7zip/CPP/7zip/Archive/Chm/ChmIn.h

@@ -0,0 +1,244 @@
+// Archive/ChmIn.h
+
+#ifndef __ARCHIVE_CHM_IN_H
+#define __ARCHIVE_CHM_IN_H
+
+#include "Common/Buffer.h"
+#include "Common/MyString.h"
+
+#include "../../IStream.h"
+#include "../../Common/InBuffer.h"
+
+#include "ChmHeader.h"
+
+namespace NArchive {
+namespace NChm {
+
+struct CItem
+{
+  UInt64 Section;
+  UInt64 Offset;
+  UInt64 Size;
+  AString Name;
+
+  bool IsFormatRelatedItem() const
+  {
+    if (Name.Length() < 2)
+      return false;
+    return Name[0] == ':' && Name[1] == ':';
+  }
+  
+  bool IsUserItem() const
+  {
+    if (Name.Length() < 2)
+      return false;
+    return Name[0] == '/';
+  }
+  
+  bool IsDir() const
+  {
+    if (Name.Length() == 0)
+      return false;
+    return (Name[Name.Length() - 1] == '/');
+  }
+};
+
+struct CDatabase
+{
+  UInt64 ContentOffset;
+  CObjectVector<CItem> Items;
+  AString NewFormatString;
+  bool Help2Format;
+  bool NewFormat;
+
+  int FindItem(const AString &name) const
+  {
+    for (int i = 0; i < Items.Size(); i++)
+      if (Items[i].Name == name)
+        return i;
+    return -1;
+  }
+
+  void Clear()
+  {
+    NewFormat = false;
+    NewFormatString.Empty();
+    Help2Format = false;
+    Items.Clear();
+  }
+};
+
+struct CResetTable
+{
+  UInt64 UncompressedSize;
+  UInt64 CompressedSize;
+  UInt64 BlockSize;
+  CRecordVector<UInt64> ResetOffsets;
+  bool GetCompressedSizeOfBlocks(UInt64 blockIndex, UInt32 numBlocks, UInt64 &size) const
+  {
+    if (blockIndex >= ResetOffsets.Size())
+      return false;
+    UInt64 startPos = ResetOffsets[(int)blockIndex];
+    if (blockIndex + numBlocks >= ResetOffsets.Size())
+      size = CompressedSize - startPos;
+    else
+      size = ResetOffsets[(int)(blockIndex + numBlocks)] - startPos;
+    return true;
+  }
+  bool GetCompressedSizeOfBlock(UInt64 blockIndex, UInt64 &size) const
+  {
+    return GetCompressedSizeOfBlocks(blockIndex, 1, size);
+  }
+  UInt64 GetNumBlocks(UInt64 size) const
+  {
+    return (size + BlockSize - 1) / BlockSize;
+  }
+};
+
+struct CLzxInfo
+{
+  UInt32 Version;
+  UInt32 ResetInterval;
+  UInt32 WindowSize;
+  UInt32 CacheSize;
+  CResetTable ResetTable;
+
+  UInt32 GetNumDictBits() const
+  {
+    if (Version == 2 || Version == 3)
+    {
+      for (int i = 0; i <= 31; i++)
+        if (((UInt32)1 << i) >= WindowSize)
+          return 15 + i;
+    }
+    return 0;
+  }
+
+  UInt64 GetFolderSize() const { return ResetTable.BlockSize * ResetInterval; };
+  UInt64 GetFolder(UInt64 offset) const { return offset / GetFolderSize(); };
+  UInt64 GetFolderPos(UInt64 folderIndex) const { return folderIndex * GetFolderSize(); };
+  UInt64 GetBlockIndexFromFolderIndex(UInt64 folderIndex) const { return folderIndex * ResetInterval; };
+  bool GetOffsetOfFolder(UInt64 folderIndex, UInt64 &offset) const
+  {
+    UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
+    if (blockIndex >= ResetTable.ResetOffsets.Size())
+      return false;
+    offset = ResetTable.ResetOffsets[(int)blockIndex];
+    return true;
+  }
+  bool GetCompressedSizeOfFolder(UInt64 folderIndex, UInt64 &size) const
+  {
+    UInt64 blockIndex = GetBlockIndexFromFolderIndex(folderIndex);
+    return ResetTable.GetCompressedSizeOfBlocks(blockIndex, ResetInterval, size);
+  }
+};
+
+struct CMethodInfo
+{
+  GUID Guid;
+  CByteBuffer ControlData;
+  CLzxInfo LzxInfo;
+  bool IsLzx() const;
+  bool IsDes() const;
+  AString GetGuidString() const;
+  UString GetName() const;
+};
+
+struct CSectionInfo
+{
+  UInt64 Offset;
+  UInt64 CompressedSize;
+  UInt64 UncompressedSize;
+
+  AString Name;
+  CObjectVector<CMethodInfo> Methods;
+
+  bool IsLzx() const;
+  UString GetMethodName() const;
+};
+
+class CFilesDatabase: public CDatabase
+{
+public:
+  bool LowLevel;
+  CRecordVector<int> Indices;
+  CObjectVector<CSectionInfo> Sections;
+
+  UInt64 GetFileSize(int fileIndex) const { return Items[Indices[fileIndex]].Size; }
+  UInt64 GetFileOffset(int fileIndex) const { return Items[Indices[fileIndex]].Offset; }
+
+  UInt64 GetFolder(int fileIndex) const
+  {
+    const CItem &item = Items[Indices[fileIndex]];
+    const CSectionInfo &section = Sections[(int)item.Section];
+    if (section.IsLzx())
+      return section.Methods[0].LzxInfo.GetFolder(item.Offset);
+    return 0;
+  }
+
+  UInt64 GetLastFolder(int fileIndex) const
+  {
+    const CItem &item = Items[Indices[fileIndex]];
+    const CSectionInfo &section = Sections[(int)item.Section];
+    if (section.IsLzx())
+      return section.Methods[0].LzxInfo.GetFolder(item.Offset + item.Size - 1);
+    return 0;
+  }
+
+  void HighLevelClear()
+  {
+    LowLevel = true;
+    Indices.Clear();
+    Sections.Clear();
+  }
+
+  void Clear()
+  {
+    CDatabase::Clear();
+    HighLevelClear();
+  }
+  void SetIndices();
+  void Sort();
+  bool Check();
+};
+
+class CProgressVirt
+{
+public:
+  STDMETHOD(SetTotal)(const UInt64 *numFiles) PURE;
+  STDMETHOD(SetCompleted)(const UInt64 *numFiles) PURE;
+};
+
+class CInArchive
+{
+  UInt64 _startPosition;
+  ::CInBuffer _inBuffer;
+  UInt64 _chunkSize;
+
+  Byte ReadByte();
+  void ReadBytes(Byte *data, UInt32 size);
+  void Skip(size_t size);
+  UInt16 ReadUInt16();
+  UInt32 ReadUInt32();
+  UInt64 ReadUInt64();
+  UInt64 ReadEncInt();
+  void ReadString(int size, AString &s);
+  void ReadUString(int size, UString &s);
+  void ReadGUID(GUID &g);
+
+  HRESULT ReadChunk(IInStream *inStream, UInt64 pos, UInt64 size);
+
+  HRESULT ReadDirEntry(CDatabase &database);
+  HRESULT DecompressStream(IInStream *inStream, const CDatabase &database, const AString &name);
+
+public:
+  HRESULT OpenChm(IInStream *inStream, CDatabase &database);
+  HRESULT OpenHelp2(IInStream *inStream, CDatabase &database);
+  HRESULT OpenHighLevel(IInStream *inStream, CFilesDatabase &database);
+  HRESULT Open2(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
+  HRESULT Open(IInStream *inStream, const UInt64 *searchHeaderSizeLimit, CFilesDatabase &database);
+};
+  
+}}
+  
+#endif

data/ext/p7zip/CPP/7zip/Archive/Chm/ChmRegister.cpp

@@ -0,0 +1,13 @@
+// ChmRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../../Common/RegisterArc.h"
+
+#include "ChmHandler.h"
+static IInArchive *CreateArc() { return new NArchive::NChm::CHandler; }
+
+static CArcInfo g_ArcInfo =
+  { L"Chm", L"chm chi chq chw hxs hxi hxr hxq hxw lit", 0, 0xE9, { 'I', 'T', 'S', 'F' }, 4, false, CreateArc, 0 };
+
+REGISTER_ARC(Chm)

data/ext/p7zip/CPP/7zip/Archive/Com/ComHandler.cpp

@@ -0,0 +1,239 @@
+// ComHandler.cpp
+
+#include "StdAfx.h"
+
+#include "Common/ComTry.h"
+
+#include "Windows/PropVariant.h"
+
+#include "../../Common/LimitedStreams.h"
+#include "../../Common/ProgressUtils.h"
+#include "../../Common/StreamUtils.h"
+
+#include "../../Compress/CopyCoder.h"
+
+#include "ComHandler.h"
+
+namespace NArchive {
+namespace NCom {
+
+STATPROPSTG kProps[] =
+{
+  { NULL, kpidPath, VT_BSTR},
+  { NULL, kpidIsDir, VT_BOOL},
+  { NULL, kpidSize, VT_UI8},
+  { NULL, kpidPackSize, VT_UI8},
+  { NULL, kpidCTime, VT_FILETIME},
+  { NULL, kpidMTime, VT_FILETIME}
+};
+
+STATPROPSTG kArcProps[] =
+{
+  { NULL, kpidClusterSize, VT_UI4},
+  { NULL, kpidSectorSize, VT_UI4}
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  switch(propID)
+  {
+    case kpidClusterSize: prop = (UInt32)1 << _db.SectorSizeBits; break;
+    case kpidSectorSize: prop = (UInt32)1 << _db.MiniSectorSizeBits; break;
+    case kpidMainSubfile: if (_db.MainSubfile >= 0) prop = (UInt32)_db.MainSubfile; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  const CRef &ref = _db.Refs[index];
+  const CItem &item = _db.Items[ref.Did];
+    
+  switch(propID)
+  {
+    case kpidPath:  prop = _db.GetItemPath(index); break;
+    case kpidIsDir:  prop = item.IsDir(); break;
+    case kpidCTime:  prop = item.CTime; break;
+    case kpidMTime:  prop = item.MTime; break;
+    case kpidPackSize:  if (!item.IsDir()) prop = _db.GetItemPackSize(item.Size); break;
+    case kpidSize:  if (!item.IsDir()) prop = item.Size; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Open(IInStream *inStream,
+    const UInt64 * /* maxCheckStartPosition */,
+    IArchiveOpenCallback * /* openArchiveCallback */)
+{
+  COM_TRY_BEGIN
+  Close();
+  try
+  {
+    if (_db.Open(inStream) != S_OK)
+      return S_FALSE;
+    _stream = inStream;
+  }
+  catch(...) { return S_FALSE; }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  _db.Clear();
+  _stream.Release();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback)
+{
+  COM_TRY_BEGIN
+  bool allFilesMode = (numItems == (UInt32)-1);
+  if (allFilesMode)
+    numItems = _db.Refs.Size();
+  if (numItems == 0)
+    return S_OK;
+  UInt32 i;
+  UInt64 totalSize = 0;
+  for(i = 0; i < numItems; i++)
+  {
+    const CItem &item = _db.Items[_db.Refs[allFilesMode ? i : indices[i]].Did];
+    if (!item.IsDir())
+      totalSize += item.Size;
+  }
+  RINOK(extractCallback->SetTotal(totalSize));
+
+  UInt64 totalPackSize;
+  totalSize = totalPackSize = 0;
+  
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
+  lps->Init(extractCallback, false);
+
+  for (i = 0; i < numItems; i++)
+  {
+    lps->InSize = totalPackSize;
+    lps->OutSize = totalSize;
+    RINOK(lps->SetCur());
+    Int32 index = allFilesMode ? i : indices[i];
+    const CItem &item = _db.Items[_db.Refs[index].Did];
+
+    CMyComPtr<ISequentialOutStream> outStream;
+    Int32 askMode = testMode ?
+        NExtract::NAskMode::kTest :
+        NExtract::NAskMode::kExtract;
+    RINOK(extractCallback->GetStream(index, &outStream, askMode));
+
+    if (item.IsDir())
+    {
+      RINOK(extractCallback->PrepareOperation(askMode));
+      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
+      continue;
+    }
+
+    totalPackSize += _db.GetItemPackSize(item.Size);
+    totalSize += item.Size;
+    
+    if (!testMode && !outStream)
+      continue;
+    RINOK(extractCallback->PrepareOperation(askMode));
+    Int32 res = NExtract::NOperationResult::kDataError;
+    CMyComPtr<ISequentialInStream> inStream;
+    HRESULT hres = GetStream(index, &inStream);
+    if (hres == S_FALSE)
+      res = NExtract::NOperationResult::kDataError;
+    else if (hres == E_NOTIMPL)
+      res = NExtract::NOperationResult::kUnSupportedMethod;
+    else
+    {
+      RINOK(hres);
+      if (inStream)
+      {
+        RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
+        if (copyCoderSpec->TotalSize == item.Size)
+          res = NExtract::NOperationResult::kOK;
+      }
+    }
+    outStream.Release();
+    RINOK(extractCallback->SetOperationResult(res));
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _db.Refs.Size();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
+{
+  COM_TRY_BEGIN
+  *stream = 0;
+  const CItem &item = _db.Items[_db.Refs[index].Did];
+  CClusterInStream *streamSpec = new CClusterInStream;
+  CMyComPtr<ISequentialInStream> streamTemp = streamSpec;
+  streamSpec->Stream = _stream;
+  streamSpec->StartOffset = 0;
+
+  bool isLargeStream = _db.IsLargeStream(item.Size);
+  int bsLog = isLargeStream ? _db.SectorSizeBits : _db.MiniSectorSizeBits;
+  streamSpec->BlockSizeLog = bsLog;
+  streamSpec->Size = item.Size;
+
+  UInt32 clusterSize = (UInt32)1 << bsLog;
+  UInt64 numClusters64 = (item.Size + clusterSize - 1) >> bsLog;
+  if (numClusters64 >= ((UInt32)1 << 31))
+    return E_NOTIMPL;
+  streamSpec->Vector.Reserve((int)numClusters64);
+  UInt32 sid = item.Sid;
+  UInt64 size = item.Size;
+
+  if (size != 0)
+  {
+    for (;; size -= clusterSize)
+    {
+      if (isLargeStream)
+      {
+        if (sid >= _db.FatSize)
+          return S_FALSE;
+        streamSpec->Vector.Add(sid + 1);
+        sid = _db.Fat[sid];
+      }
+      else
+      {
+        UInt64 val;
+        if (sid >= _db.MatSize || !_db.GetMiniCluster(sid, val) || val >= (UInt64)1 << 32)
+          return S_FALSE;
+        streamSpec->Vector.Add((UInt32)val);
+        sid = _db.Mat[sid];
+      }
+      if (size <= clusterSize)
+        break;
+    }
+  }
+  if (sid != NFatID::kEndOfChain)
+    return S_FALSE;
+  RINOK(streamSpec->InitAndSeek());
+  *stream = streamTemp.Detach();
+  return S_OK;
+  COM_TRY_END
+}
+
+}}