seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -8,41 +8,40 @@
 template<class TOutByte>
 class CBitmEncoder
 {
-  TOutByte m_Stream;
-  unsigned m_BitPos;
-  Byte m_CurByte;
+  unsigned _bitPos;
+  Byte _curByte;
+  TOutByte _stream;
 public:
-  bool Create(UInt32 bufferSize) { return m_Stream.Create(bufferSize); }
-  void SetStream(ISequentialOutStream *outStream) { m_Stream.SetStream(outStream);}
-  void ReleaseStream() { m_Stream.ReleaseStream(); }
-  UInt64 GetProcessedSize() const { return m_Stream.GetProcessedSize() + (8 - m_BitPos + 7) / 8; }
+  bool Create(UInt32 bufferSize) { return _stream.Create(bufferSize); }
+  void SetStream(ISequentialOutStream *outStream) { _stream.SetStream(outStream);}
+  UInt64 GetProcessedSize() const { return _stream.GetProcessedSize() + ((8 - _bitPos + 7) >> 3); }
   void Init()
   {
-    m_Stream.Init();
-    m_BitPos = 8;
-    m_CurByte = 0;
+    _stream.Init();
+    _bitPos = 8;
+    _curByte = 0;
   }
   HRESULT Flush()
   {
-    if (m_BitPos < 8)
-      WriteBits(0, m_BitPos);
-    return m_Stream.Flush();
+    if (_bitPos < 8)
+      WriteBits(0, _bitPos);
+    return _stream.Flush();
   }
   void WriteBits(UInt32 value, unsigned numBits)
   {
     while (numBits > 0)
     {
-      if (numBits < m_BitPos)
+      if (numBits < _bitPos)
       {
-        m_CurByte |= ((Byte)value << (m_BitPos -= numBits));
+        _curByte |= ((Byte)value << (_bitPos -= numBits));
         return;
       }
-      numBits -= m_BitPos;
+      numBits -= _bitPos;
       UInt32 newBits = (value >> numBits);
       value -= (newBits << numBits);
-      m_Stream.WriteByte((Byte)(m_CurByte | newBits));
-      m_BitPos = 8;
-      m_CurByte = 0;
+      _stream.WriteByte((Byte)(_curByte | newBits));
+      _bitPos = 8;
+      _curByte = 0;
     }
   }
 };

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

@@ -2,36 +2,22 @@
 
 #include "StdAfx.h"
 
-#include "../../../C/Bra.h"
-
 #include "BranchMisc.h"
 
-UInt32 CBC_ARM_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARM_Convert(data, size, _bufferPos, 1); }
-
-UInt32 CBC_ARM_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARM_Convert(data, size, _bufferPos, 0); }
-
-UInt32 CBC_ARMT_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARMT_Convert(data, size, _bufferPos, 1); }
-
-UInt32 CBC_ARMT_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::ARMT_Convert(data, size, _bufferPos, 0); }
-
-UInt32 CBC_PPC_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::PPC_Convert(data, size, _bufferPos, 1); }
-
-UInt32 CBC_PPC_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::PPC_Convert(data, size, _bufferPos, 0); }
-
-UInt32 CBC_SPARC_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::SPARC_Convert(data, size, _bufferPos, 1); }
+namespace NCompress {
+namespace NBranch {
 
-UInt32 CBC_SPARC_Decoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::SPARC_Convert(data, size, _bufferPos, 0); }
+STDMETHODIMP CCoder::Init()
+{
+  _bufferPos = 0;
+  return S_OK;
+}
 
-UInt32 CBC_IA64_Encoder::SubFilter(Byte *data, UInt32 size)
-  { return (UInt32)::IA64_Convert(data, size, _bufferPos, 1); }
+STDMETHODIMP_(UInt32) CCoder::Filter(Byte *data, UInt32 size)
+{
+  UInt32 processed = (UInt32)BraFunc(data, size, _bufferPos, _encode);
+  _bufferPos += processed;
+  return processed;
+}
 
-UInt32 CBC_IA64_Decoder::SubFilter(Byte *data, UInt32 size)
-  {  return (UInt32)::IA64_Convert(data, size, _bufferPos, 0); }
+}}

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

@@ -3,12 +3,33 @@
 #ifndef __COMPRESS_BRANCH_MISC_H
 #define __COMPRESS_BRANCH_MISC_H
 
-#include "BranchCoder.h"
+#include "../../Common/MyCom.h"
 
-MyClassA(BC_ARM,   0x05, 1)
-MyClassA(BC_ARMT,  0x07, 1)
-MyClassA(BC_PPC,   0x02, 5)
-MyClassA(BC_SPARC, 0x08, 5)
-MyClassA(BC_IA64,  0x04, 1)
+#include "../ICoder.h"
+
+EXTERN_C_BEGIN
+
+typedef SizeT (*Func_Bra)(Byte *data, SizeT size, UInt32 ip, int encoding);
+
+EXTERN_C_END
+
+namespace NCompress {
+namespace NBranch {
+
+class CCoder:
+  public ICompressFilter,
+  public CMyUnknownImp
+{
+  UInt32 _bufferPos;
+  int _encode;
+  Func_Bra BraFunc;
+public:
+  MY_UNKNOWN_IMP1(ICompressFilter);
+  INTERFACE_ICompressFilter(;)
+
+  CCoder(Func_Bra bra, int encode):  _bufferPos(0), _encode(encode), BraFunc(bra) {}
+};
+
+}}
 
 #endif

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

@@ -2,29 +2,40 @@
 
 #include "StdAfx.h"
 
+#include "../../../C/Bra.h"
+
 #include "../Common/RegisterCodec.h"
 
 #include "BranchMisc.h"
 
-#define CREATE_CODEC(x) \
-  static void *CreateCodec ## x() { return (void *)(ICompressFilter *)(new C ## x ## _Decoder); } \
-  static void *CreateCodec ## x ## Out() { return (void *)(ICompressFilter *)(new C ## x ## _Encoder); }
+namespace NCompress {
+namespace NBranch {
+
+#define CREATE_BRA(n) \
+    REGISTER_FILTER_CREATE(CreateBra_Decoder_ ## n, CCoder(n ## _Convert, false)) \
+    REGISTER_FILTER_CREATE(CreateBra_Encoder_ ## n, CCoder(n ## _Convert, true)) \
 
-CREATE_CODEC(BC_PPC)
-CREATE_CODEC(BC_IA64)
-CREATE_CODEC(BC_ARM)
-CREATE_CODEC(BC_ARMT)
-CREATE_CODEC(BC_SPARC)
+CREATE_BRA(PPC)
+CREATE_BRA(IA64)
+CREATE_BRA(ARM)
+CREATE_BRA(ARMT)
+CREATE_BRA(SPARC)
 
-#define METHOD_ITEM(x, id1, id2, name) { CreateCodec ## x, CreateCodec ## x ## Out, 0x03030000 + (id1 * 256) + id2, name, 1, true  }
+#define METHOD_ITEM(n, id, name) \
+    REGISTER_FILTER_ITEM( \
+      CreateBra_Decoder_ ## n, \
+      CreateBra_Encoder_ ## n, \
+      0x3030000 + id, name)
 
-static CCodecInfo g_CodecsInfo[] =
+REGISTER_CODECS_VAR
 {
-  METHOD_ITEM(BC_PPC,   0x02, 0x05, L"PPC"),
-  METHOD_ITEM(BC_IA64,  0x04, 1, L"IA64"),
-  METHOD_ITEM(BC_ARM,   0x05, 1, L"ARM"),
-  METHOD_ITEM(BC_ARMT,  0x07, 1, L"ARMT"),
-  METHOD_ITEM(BC_SPARC, 0x08, 0x05, L"SPARC")
+  METHOD_ITEM(PPC,   0x205, "PPC"),
+  METHOD_ITEM(IA64,  0x401, "IA64"),
+  METHOD_ITEM(ARM,   0x501, "ARM"),
+  METHOD_ITEM(ARMT,  0x701, "ARMT"),
+  METHOD_ITEM(SPARC, 0x805, "SPARC")
 };
 
 REGISTER_CODECS(Branch)
+
+}}

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

@@ -8,14 +8,16 @@
 
 #include "../Common/RegisterCodec.h"
 
+namespace NCompress {
+namespace NByteSwap {
+
 class CByteSwap2:
   public ICompressFilter,
   public CMyUnknownImp
 {
 public:
-  MY_UNKNOWN_IMP
-  STDMETHOD(Init)();
-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  MY_UNKNOWN_IMP1(ICompressFilter);
+  INTERFACE_ICompressFilter(;)
 };
 
 class CByteSwap4:
@@ -23,9 +25,8 @@ class CByteSwap4:
   public CMyUnknownImp
 {
 public:
-  MY_UNKNOWN_IMP
-  STDMETHOD(Init)();
-  STDMETHOD_(UInt32, Filter)(Byte *data, UInt32 size);
+  MY_UNKNOWN_IMP1(ICompressFilter);
+  INTERFACE_ICompressFilter(;)
 };
 
 STDMETHODIMP CByteSwap2::Init() { return S_OK; }
@@ -33,14 +34,22 @@ STDMETHODIMP CByteSwap2::Init() { return S_OK; }
 STDMETHODIMP_(UInt32) CByteSwap2::Filter(Byte *data, UInt32 size)
 {
   const UInt32 kStep = 2;
-  UInt32 i;
-  for (i = 0; i + kStep <= size; i += kStep)
+  if (size < kStep)
+    return 0;
+  size &= ~(kStep - 1);
+  
+  const Byte *end = data + (size_t)size;
+  
+  do
   {
-    Byte b = data[i];
-    data[i] = data[i + 1];
-    data[i + 1] = b;
+    Byte b0 = data[0];
+    data[0] = data[1];
+    data[1] = b0;
+    data += kStep;
   }
-  return i;
+  while (data != end);
+
+  return size;
 }
 
 STDMETHODIMP CByteSwap4::Init() { return S_OK; }
@@ -48,26 +57,36 @@ STDMETHODIMP CByteSwap4::Init() { return S_OK; }
 STDMETHODIMP_(UInt32) CByteSwap4::Filter(Byte *data, UInt32 size)
 {
   const UInt32 kStep = 4;
-  UInt32 i;
-  for (i = 0; i + kStep <= size; i += kStep)
+  if (size < kStep)
+    return 0;
+  size &= ~(kStep - 1);
+  
+  const Byte *end = data + (size_t)size;
+  
+  do
   {
-    Byte b0 = data[i];
-    Byte b1 = data[i + 1];
-    data[i] = data[i + 3];
-    data[i + 1] = data[i + 2];
-    data[i + 2] = b1;
-    data[i + 3] = b0;
+    Byte b0 = data[0];
+    Byte b1 = data[1];
+    data[0] = data[3];
+    data[1] = data[2];
+    data[2] = b1;
+    data[3] = b0;
+    data += kStep;
   }
-  return i;
+  while (data != end);
+
+  return size;
 }
 
-static void *CreateCodec2() { return (void *)(ICompressFilter *)(new CByteSwap2); }
-static void *CreateCodec4() { return (void *)(ICompressFilter *)(new CByteSwap4); }
+REGISTER_FILTER_CREATE(CreateFilter2, CByteSwap2())
+REGISTER_FILTER_CREATE(CreateFilter4, CByteSwap4())
 
-static CCodecInfo g_CodecsInfo[] =
+REGISTER_CODECS_VAR
 {
-  { CreateCodec2, CreateCodec2, 0x020302, L"Swap2", 1, true },
-  { CreateCodec4, CreateCodec4, 0x020304, L"Swap4", 1, true }
+  REGISTER_FILTER_ITEM(CreateFilter2, CreateFilter2, 0x20302, "Swap2"),
+  REGISTER_FILTER_ITEM(CreateFilter4, CreateFilter4, 0x20304, "Swap4")
 };
 
 REGISTER_CODECS(ByteSwap)
+
+}}