seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -5,28 +5,74 @@
 
 #include "../Archive/IArchive.h"
 
-typedef IInArchive * (*CreateInArchiveP)();
-typedef IOutArchive * (*CreateOutArchiveP)();
-
 struct CArcInfo
 {
-  const wchar_t *Name;
-  const wchar_t *Ext;
-  const wchar_t *AddExt;
-  Byte ClassId;
-  Byte Signature[28];  // FIXME Byte Signature[16]; adding 22 bytes to insure kSignature[0x1A]!= 0 and  kSignature[0x1B] != 0
-  int SignatureSize;
-  bool KeepName;
-  CreateInArchiveP CreateInArchive;
-  CreateOutArchiveP CreateOutArchive;
+  UInt16 Flags;
+  Byte Id;
+  Byte SignatureSize;
+  UInt16 SignatureOffset;
+  
+  const Byte *Signature;
+  const char *Name;
+  const char *Ext;
+  const char *AddExt;
+  
+  Func_CreateInArchive CreateInArchive;
+  Func_CreateOutArchive CreateOutArchive;
+  Func_IsArc IsArc;
+
+  bool IsMultiSignature() const { return (Flags & NArcInfoFlags::kMultiSignature) != 0; }
 };
 
-void RegisterArc(const CArcInfo *arcInfo);
+void RegisterArc(const CArcInfo *arcInfo) throw();
+
+
+#define IMP_CreateArcIn_2(c) \
+  static IInArchive *CreateArc() { return new c; }
+
+#define IMP_CreateArcIn IMP_CreateArcIn_2(CHandler())
+
+#ifdef EXTRACT_ONLY
+  #define IMP_CreateArcOut
+  #define CreateArcOut NULL
+#else
+  #define IMP_CreateArcOut static IOutArchive *CreateArcOut() { return new CHandler(); }
+#endif
+
+#define REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
+  static const CArcInfo g_ArcInfo = { flags, id, sigSize, offs, sig, n, e, ae, crIn, crOut, isArc } ; \
+
+#define REGISTER_ARC_R(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
+  REGISTER_ARC_V(n, e, ae, id, sigSize, sig, offs, flags, crIn, crOut, isArc) \
+  struct CRegisterArc { CRegisterArc() { RegisterArc(&g_ArcInfo); }}; \
+  static CRegisterArc g_RegisterArc;
+
+
+#define REGISTER_ARC_I_CLS(cls, n, e, ae, id, sig, offs, flags, isArc) \
+  IMP_CreateArcIn_2(cls) \
+  REGISTER_ARC_R(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, NULL, isArc)
+
+#define REGISTER_ARC_I_CLS_NO_SIG(cls, n, e, ae, id, offs, flags, isArc) \
+  IMP_CreateArcIn_2(cls) \
+  REGISTER_ARC_R(n, e, ae, id, 0, NULL, offs, flags, CreateArc, NULL, isArc)
+
+#define REGISTER_ARC_I(n, e, ae, id, sig, offs, flags, isArc) \
+  REGISTER_ARC_I_CLS(CHandler(), n, e, ae, id, sig, offs, flags, isArc)
+
+#define REGISTER_ARC_I_NO_SIG(n, e, ae, id, offs, flags, isArc) \
+  REGISTER_ARC_I_CLS_NO_SIG(CHandler(), n, e, ae, id, offs, flags, isArc)
+
 
-#define REGISTER_ARC_NAME(x) CRegister ## x
+#define REGISTER_ARC_IO(n, e, ae, id, sig, offs, flags, isArc) \
+  IMP_CreateArcIn \
+  IMP_CreateArcOut \
+  REGISTER_ARC_R(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, CreateArcOut, isArc)
 
-#define REGISTER_ARC(x) struct REGISTER_ARC_NAME(x) { \
-    REGISTER_ARC_NAME(x)() { RegisterArc(&g_ArcInfo); }}; \
-    static REGISTER_ARC_NAME(x) g_RegisterArc;
+#define REGISTER_ARC_IO_DECREMENT_SIG(n, e, ae, id, sig, offs, flags, isArc) \
+  IMP_CreateArcIn \
+  IMP_CreateArcOut \
+  REGISTER_ARC_V(n, e, ae, id, ARRAY_SIZE(sig), sig, offs, flags, CreateArc, CreateArcOut, isArc) \
+  struct CRegisterArcDecSig { CRegisterArcDecSig() { sig[0]--; RegisterArc(&g_ArcInfo); }}; \
+  static CRegisterArcDecSig g_RegisterArc;
 
 #endif

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

@@ -1,33 +1,106 @@
 // RegisterCodec.h
 
-#ifndef __REGISTERCODEC_H
-#define __REGISTERCODEC_H
+#ifndef __REGISTER_CODEC_H
+#define __REGISTER_CODEC_H
 
 #include "../Common/MethodId.h"
 
+#include "../ICoder.h"
+
 typedef void * (*CreateCodecP)();
+
 struct CCodecInfo
 {
   CreateCodecP CreateDecoder;
   CreateCodecP CreateEncoder;
   CMethodId Id;
-  const wchar_t *Name;
-  UInt32 NumInStreams;
+  const char *Name;
+  UInt32 NumStreams;
   bool IsFilter;
 };
 
-void RegisterCodec(const CCodecInfo *codecInfo);
+void RegisterCodec(const CCodecInfo *codecInfo) throw();
+
+
+#define REGISTER_CODEC_CREATE_2(name, cls, i) static void *name() { return (void *)(i *)(new cls); }
+#define REGISTER_CODEC_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressCoder)
 
 #define REGISTER_CODEC_NAME(x) CRegisterCodec ## x
+#define REGISTER_CODEC_VAR static const CCodecInfo g_CodecInfo =
 
 #define REGISTER_CODEC(x) struct REGISTER_CODEC_NAME(x) { \
     REGISTER_CODEC_NAME(x)() { RegisterCodec(&g_CodecInfo); }}; \
     static REGISTER_CODEC_NAME(x) g_RegisterCodec;
 
+
 #define REGISTER_CODECS_NAME(x) CRegisterCodecs ## x
+#define REGISTER_CODECS_VAR static const CCodecInfo g_CodecsInfo[] =
+
 #define REGISTER_CODECS(x) struct REGISTER_CODECS_NAME(x) { \
-    REGISTER_CODECS_NAME(x)() { for (int i = 0; i < sizeof(g_CodecsInfo) / sizeof(g_CodecsInfo[0]); i++) \
+    REGISTER_CODECS_NAME(x)() { for (unsigned i = 0; i < ARRAY_SIZE(g_CodecsInfo); i++) \
     RegisterCodec(&g_CodecsInfo[i]); }}; \
     static REGISTER_CODECS_NAME(x) g_RegisterCodecs;
 
+
+#define REGISTER_CODEC_2(x, crDec, crEnc, id, name) \
+    REGISTER_CODEC_VAR \
+    { crDec, crEnc, id, name, 1, false }; \
+    REGISTER_CODEC(x)
+
+
+#ifdef EXTRACT_ONLY
+  #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
+    REGISTER_CODEC_CREATE(CreateDec, clsDec) \
+    REGISTER_CODEC_2(x, CreateDec, NULL, id, name)
+#else
+  #define REGISTER_CODEC_E(x, clsDec, clsEnc, id, name) \
+    REGISTER_CODEC_CREATE(CreateDec, clsDec) \
+    REGISTER_CODEC_CREATE(CreateEnc, clsEnc) \
+    REGISTER_CODEC_2(x, CreateDec, CreateEnc, id, name)
+#endif
+
+
+
+#define REGISTER_FILTER_CREATE(name, cls) REGISTER_CODEC_CREATE_2(name, cls, ICompressFilter)
+
+#define REGISTER_FILTER_ITEM(crDec, crEnc, id, name) \
+    { crDec, crEnc, id, name, 1, true }
+
+#define REGISTER_FILTER(x, crDec, crEnc, id, name) \
+    REGISTER_CODEC_VAR \
+    REGISTER_FILTER_ITEM(crDec, crEnc, id, name); \
+    REGISTER_CODEC(x)
+
+#ifdef EXTRACT_ONLY
+  #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
+    REGISTER_FILTER_CREATE(CreateDec, clsDec) \
+    REGISTER_FILTER(x, CreateDec, NULL, id, name)
+#else
+  #define REGISTER_FILTER_E(x, clsDec, clsEnc, id, name) \
+    REGISTER_FILTER_CREATE(CreateDec, clsDec) \
+    REGISTER_FILTER_CREATE(CreateEnc, clsEnc) \
+    REGISTER_FILTER(x, CreateDec, CreateEnc, id, name)
+#endif
+
+
+
+struct CHasherInfo
+{
+  IHasher * (*CreateHasher)();
+  CMethodId Id;
+  const char *Name;
+  UInt32 DigestSize;
+};
+
+void RegisterHasher(const CHasherInfo *hasher) throw();
+
+#define REGISTER_HASHER_NAME(x) CRegHasher_ ## x
+
+#define REGISTER_HASHER(cls, id, name, size) \
+    STDMETHODIMP_(UInt32) cls::GetDigestSize() throw() { return size; } \
+    static IHasher *CreateHasherSpec() { return new cls(); } \
+    static const CHasherInfo g_HasherInfo = { CreateHasherSpec, id, name, size }; \
+    struct REGISTER_HASHER_NAME(cls) { REGISTER_HASHER_NAME(cls)() { RegisterHasher(&g_HasherInfo); }}; \
+    static REGISTER_HASHER_NAME(cls) g_RegisterHasher;
+
 #endif

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

@@ -2,151 +2,156 @@
 
 #include "StdAfx.h"
 
-#include "StreamBinder.h"
-#include "../../Common/Defs.h"
 #include "../../Common/MyCom.h"
 
-using namespace NWindows;
-using namespace NSynchronization;
+#include "StreamBinder.h"
 
-class CSequentialInStreamForBinder:
+class CBinderInStream:
   public ISequentialInStream,
   public CMyUnknownImp
 {
+  CStreamBinder *_binder;
 public:
-  MY_UNKNOWN_IMP
-
+  MY_UNKNOWN_IMP1(ISequentialInStream)
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-private:
-  CStreamBinder *m_StreamBinder;
-public:
-  ~CSequentialInStreamForBinder() { m_StreamBinder->CloseRead(); }
-  void SetBinder(CStreamBinder *streamBinder) { m_StreamBinder = streamBinder; }
+  ~CBinderInStream() { _binder->CloseRead(); }
+  CBinderInStream(CStreamBinder *binder): _binder(binder) {}
 };
 
-STDMETHODIMP CSequentialInStreamForBinder::Read(void *data, UInt32 size, UInt32 *processedSize)
-  { return m_StreamBinder->Read(data, size, processedSize); }
+STDMETHODIMP CBinderInStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+  { return _binder->Read(data, size, processedSize); }
 
-class CSequentialOutStreamForBinder:
+class CBinderOutStream:
   public ISequentialOutStream,
   public CMyUnknownImp
 {
+  CStreamBinder *_binder;
 public:
-  MY_UNKNOWN_IMP
-
+  MY_UNKNOWN_IMP1(ISequentialOutStream)
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-
-private:
-  CStreamBinder *m_StreamBinder;
-public:
-  ~CSequentialOutStreamForBinder() {  m_StreamBinder->CloseWrite(); }
-  void SetBinder(CStreamBinder *streamBinder) { m_StreamBinder = streamBinder; }
+  ~CBinderOutStream() { _binder->CloseWrite(); }
+  CBinderOutStream(CStreamBinder *binder): _binder(binder) {}
 };
 
-STDMETHODIMP CSequentialOutStreamForBinder::Write(const void *data, UInt32 size, UInt32 *processedSize)
-  { return m_StreamBinder->Write(data, size, processedSize); }
+STDMETHODIMP CBinderOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+  { return _binder->Write(data, size, processedSize); }
 
 
-//////////////////////////
-// CStreamBinder
-// (_thereAreBytesToReadEvent && _bufferSize == 0) means that stream is finished.
 
-HRes CStreamBinder::CreateEvents()
+WRes CStreamBinder::CreateEvents()
 {
-  _synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent = new NWindows::NSynchronization::CSynchro();
-  _synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent->Create();
-  RINOK(_allBytesAreWritenEvent.Create(_synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent,true));
-  RINOK(_thereAreBytesToReadEvent.Create());
-  return _readStreamIsClosedEvent.Create(_synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent);
+  _synchroFor_canWrite_Event_and_readingWasClosed_Event.Create();
+  RINOK(_canWrite_Event.Create(&_synchroFor_canWrite_Event_and_readingWasClosed_Event));
+  RINOK(_canRead_Event.Create());
+  return _readingWasClosed_Event.Create(&_synchroFor_canWrite_Event_and_readingWasClosed_Event);
 }
 
 void CStreamBinder::ReInit()
 {
-  _thereAreBytesToReadEvent.Reset();
-  _readStreamIsClosedEvent.Reset();
+  _canWrite_Event.Reset();
+  _canRead_Event.Reset();
+  _readingWasClosed_Event.Reset();
+
+  // _readingWasClosed = false;
+  _readingWasClosed2 = false;
+
+  _waitWrite = true;
+  _bufSize = 0;
+  _buf = NULL;
   ProcessedSize = 0;
+  // WritingWasCut = false;
 }
 
 
-  
-void CStreamBinder::CreateStreams(ISequentialInStream **inStream,
-      ISequentialOutStream **outStream)
+void CStreamBinder::CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream)
 {
-  CSequentialInStreamForBinder *inStreamSpec = new
-      CSequentialInStreamForBinder;
+  // _readingWasClosed = false;
+  _readingWasClosed2 = false;
+
+  _waitWrite = true;
+  _bufSize = 0;
+  _buf = NULL;
+  ProcessedSize = 0;
+  // WritingWasCut = false;
+
+  CBinderInStream *inStreamSpec = new CBinderInStream(this);
   CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
-  inStreamSpec->SetBinder(this);
   *inStream = inStreamLoc.Detach();
 
-  CSequentialOutStreamForBinder *outStreamSpec = new
-      CSequentialOutStreamForBinder;
+  CBinderOutStream *outStreamSpec = new CBinderOutStream(this);
   CMyComPtr<ISequentialOutStream> outStreamLoc(outStreamSpec);
-  outStreamSpec->SetBinder(this);
   *outStream = outStreamLoc.Detach();
-
-  _buffer = NULL;
-  _bufferSize= 0;
-  ProcessedSize = 0;
 }
 
+// (_canRead_Event && _bufSize == 0) means that stream is finished.
+
 HRESULT CStreamBinder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
-  UInt32 sizeToRead = size;
-  if (size > 0)
+  if (processedSize)
+    *processedSize = 0;
+  if (size != 0)
   {
-    RINOK(_thereAreBytesToReadEvent.Lock());
-    sizeToRead = MyMin(_bufferSize, size);
-    if (_bufferSize > 0)
+    if (_waitWrite)
+    {
+      RINOK(_canRead_Event.Lock());
+      _waitWrite = false;
+    }
+    if (size > _bufSize)
+      size = _bufSize;
+    if (size != 0)
     {
-      memcpy(data, _buffer, sizeToRead);
-      _buffer = ((const Byte *)_buffer) + sizeToRead;
-      _bufferSize -= sizeToRead;
-      if (_bufferSize == 0)
+      memcpy(data, _buf, size);
+      _buf = ((const Byte *)_buf) + size;
+      ProcessedSize += size;
+      if (processedSize)
+        *processedSize = size;
+      _bufSize -= size;
+      if (_bufSize == 0)
       {
-        _thereAreBytesToReadEvent.Reset();
-        _allBytesAreWritenEvent.Set();
+        _waitWrite = true;
+        _canRead_Event.Reset();
+        _canWrite_Event.Set();
       }
     }
   }
-  if (processedSize != NULL)
-    *processedSize = sizeToRead;
-  ProcessedSize += sizeToRead;
   return S_OK;
 }
 
-void CStreamBinder::CloseRead()
-{
-  _readStreamIsClosedEvent.Set();
-}
-
 HRESULT CStreamBinder::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
-  if (size > 0)
+  if (processedSize)
+    *processedSize = 0;
+  if (size == 0)
+    return S_OK;
+
+  if (!_readingWasClosed2)
   {
-    _buffer = data;
-    _bufferSize = size;
-    _allBytesAreWritenEvent.Reset();
-    _thereAreBytesToReadEvent.Set();
-
-    HANDLE events[2];
-    events[0] = _allBytesAreWritenEvent;
-    events[1] = _readStreamIsClosedEvent;
+    _buf = data;
+    _bufSize = size;
+    _canRead_Event.Set();
+    
+    /*
+    _canWrite_Event.Lock();
+    if (_readingWasClosed)
+      _readingWasClosed2 = true;
+    */
+
+    HANDLE events[2] = { _canWrite_Event, _readingWasClosed_Event };
     DWORD waitResult = ::WaitForMultipleObjects(2, events, FALSE, INFINITE);
-    if (waitResult != WAIT_OBJECT_0 + 0)
+    if (waitResult >= WAIT_OBJECT_0 + 2)
+      return E_FAIL;
+
+    size -= _bufSize;
+    if (size != 0)
     {
-      // ReadingWasClosed = true;
-      return S_FALSE;
+      if (processedSize)
+        *processedSize = size;
+      return S_OK;
     }
-    // if(!_allBytesAreWritenEvent.Lock())
-    //   return E_FAIL;
+    // if (waitResult == WAIT_OBJECT_0 + 1)
+      _readingWasClosed2 = true;
   }
-  if (processedSize != NULL)
-    *processedSize = size;
-  return S_OK;
-}
 
-void CStreamBinder::CloseWrite()
-{
-  // _bufferSize must be = 0
-  _thereAreBytesToReadEvent.Set();
+  // WritingWasCut = true;
+  return k_My_HRESULT_WritingWasCut;
 }

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

@@ -1,38 +1,61 @@
 // StreamBinder.h
 
-#ifndef __STREAMBINDER_H
-#define __STREAMBINDER_H
+#ifndef __STREAM_BINDER_H
+#define __STREAM_BINDER_H
 
-#include "../IStream.h"
 #include "../../Windows/Synchronization.h"
 
+#include "../IStream.h"
+
+/*
+We don't use probably UNSAFE version:
+reader thread:
+     _canWrite_Event.Set();
+     _readingWasClosed = true
+     _canWrite_Event.Set();
+writer thread:
+     _canWrite_Event.Wait()
+      if (_readingWasClosed)
+Can second call of _canWrite_Event.Set() be executed without memory barrier, if event is already set?
+*/
+
 class CStreamBinder
 {
-  NWindows::NSynchronization::CManualResetEventWFMO _allBytesAreWritenEvent;
-  NWindows::NSynchronization::CManualResetEvent _thereAreBytesToReadEvent;
-  NWindows::NSynchronization::CManualResetEventWFMO _readStreamIsClosedEvent;
-  NWindows::NSynchronization::CSynchro * _synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent;
-  UInt32 _bufferSize;
-  const void *_buffer;
+  NWindows::NSynchronization::CSynchro _synchroFor_canWrite_Event_and_readingWasClosed_Event;
+  NWindows::NSynchronization::CAutoResetEventWFMO _canWrite_Event;
+  NWindows::NSynchronization::CManualResetEvent _canRead_Event;
+  NWindows::NSynchronization::CManualResetEventWFMO _readingWasClosed_Event;
+
+  // bool _readingWasClosed;
+  bool _readingWasClosed2;
+  // bool WritingWasCut;
+  bool _waitWrite;
+  UInt32 _bufSize;
+  const void *_buf;
 public:
-  // bool ReadingWasClosed;
   UInt64 ProcessedSize;
-  CStreamBinder() { _synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent = 0; }
-  ~CStreamBinder() {
-	if (_synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent)
-		delete _synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent;
-	_synchroFor_allBytesAreWritenEvent_and_readStreamIsClosedEvent = 0;
-  }
-  HRes CreateEvents();
 
-  void CreateStreams(ISequentialInStream **inStream,
-      ISequentialOutStream **outStream);
+  WRes CreateEvents();
+  void CreateStreams(ISequentialInStream **inStream, ISequentialOutStream **outStream);
+  
+  void ReInit();
+  
   HRESULT Read(void *data, UInt32 size, UInt32 *processedSize);
-  void CloseRead();
-
   HRESULT Write(const void *data, UInt32 size, UInt32 *processedSize);
-  void CloseWrite();
-  void ReInit();
+
+  void CloseRead()
+  {
+    _readingWasClosed_Event.Set();
+    // _readingWasClosed = true;
+    // _canWrite_Event.Set();
+  }
+  
+  void CloseWrite()
+  {
+    _buf = NULL;
+    _bufSize = 0;
+    _canRead_Event.Set();
+  }
 };
 
 #endif