react-native-update 10.34.2 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/LzmaDecoder.cpp

@@ -0,0 +1,343 @@
+// LzmaDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/StreamUtils.h"
+
+#include "LzmaDecoder.h"
+
+static 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_UNSUPPORTED: return E_NOTIMPL;
+    case SZ_ERROR_DATA: return S_FALSE;
+  }
+  return E_FAIL;
+}
+
+namespace NCompress {
+namespace NLzma {
+
+CDecoder::CDecoder():
+    _inBuf(NULL),
+    _lzmaStatus(LZMA_STATUS_NOT_SPECIFIED),
+    FinishStream(false),
+    _propsWereSet(false),
+    _outSizeDefined(false),
+    _outStep(1 << 20),
+    _inBufSize(0),
+    _inBufSizeNew(1 << 20)
+{
+  _inProcessed = 0;
+  _inPos = _inLim = 0;
+
+  /*
+  AlignOffsetAlloc_CreateVTable(&_alloc);
+  _alloc.numAlignBits = 7;
+  _alloc.offset = 0;
+  */
+  LzmaDec_Construct(&_state);
+}
+
+CDecoder::~CDecoder()
+{
+  LzmaDec_Free(&_state, &g_AlignedAlloc); // &_alloc.vt
+  MyFree(_inBuf);
+}
+
+STDMETHODIMP CDecoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSizeNew = size; return S_OK; }
+STDMETHODIMP CDecoder::SetOutBufSize(UInt32 , UInt32 size) { _outStep = size; return S_OK; }
+
+HRESULT CDecoder::CreateInputBuffer()
+{
+  if (!_inBuf || _inBufSizeNew != _inBufSize)
+  {
+    MyFree(_inBuf);
+    _inBufSize = 0;
+    _inBuf = (Byte *)MyAlloc(_inBufSizeNew);
+    if (!_inBuf)
+      return E_OUTOFMEMORY;
+    _inBufSize = _inBufSizeNew;
+  }
+  return S_OK;
+}
+
+
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
+{
+  RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_AlignedAlloc))) // &_alloc.vt
+  _propsWereSet = true;
+  return CreateInputBuffer();
+}
+
+
+void CDecoder::SetOutStreamSizeResume(const UInt64 *outSize)
+{
+  _outSizeDefined = (outSize != NULL);
+  _outSize = 0;
+  if (_outSizeDefined)
+    _outSize = *outSize;
+  _outProcessed = 0;
+  _lzmaStatus = LZMA_STATUS_NOT_SPECIFIED;
+
+  LzmaDec_Init(&_state);
+}
+
+
+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
+{
+  _inProcessed = 0;
+  _inPos = _inLim = 0;
+  SetOutStreamSizeResume(outSize);
+  return S_OK;
+}
+
+
+STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
+{
+  FinishStream = (finishMode != 0);
+  return S_OK;
+}
+
+
+STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
+{
+  *value = _inProcessed;
+  return S_OK;
+}
+
+
+HRESULT CDecoder::CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress)
+{
+  if (!_inBuf || !_propsWereSet)
+    return S_FALSE;
+  
+  const UInt64 startInProgress = _inProcessed;
+  SizeT wrPos = _state.dicPos;
+  HRESULT readRes = S_OK;
+
+  for (;;)
+  {
+    if (_inPos == _inLim && readRes == S_OK)
+    {
+      _inPos = _inLim = 0;
+      readRes = inStream->Read(_inBuf, _inBufSize, &_inLim);
+    }
+
+    const SizeT dicPos = _state.dicPos;
+    SizeT size;
+    {
+      SizeT next = _state.dicBufSize;
+      if (next - wrPos > _outStep)
+        next = wrPos + _outStep;
+      size = next - dicPos;
+    }
+
+    ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+    if (_outSizeDefined)
+    {
+      const UInt64 rem = _outSize - _outProcessed;
+      if (size >= rem)
+      {
+        size = (SizeT)rem;
+        if (FinishStream)
+          finishMode = LZMA_FINISH_END;
+      }
+    }
+
+    SizeT inProcessed = _inLim - _inPos;
+    ELzmaStatus status;
+    
+    SRes res = LzmaDec_DecodeToDic(&_state, dicPos + size, _inBuf + _inPos, &inProcessed, finishMode, &status);
+
+    _lzmaStatus = status;
+    _inPos += (UInt32)inProcessed;
+    _inProcessed += inProcessed;
+    const SizeT outProcessed = _state.dicPos - dicPos;
+    _outProcessed += outProcessed;
+
+    // we check for LZMA_STATUS_NEEDS_MORE_INPUT to allow RangeCoder initialization, if (_outSizeDefined && _outSize == 0)
+    bool outFinished = (_outSizeDefined && _outProcessed >= _outSize);
+
+    bool needStop = (res != 0
+        || (inProcessed == 0 && outProcessed == 0)
+        || status == LZMA_STATUS_FINISHED_WITH_MARK
+        || (outFinished && status != LZMA_STATUS_NEEDS_MORE_INPUT));
+
+    if (needStop || outProcessed >= size)
+    {
+      HRESULT res2 = WriteStream(outStream, _state.dic + wrPos, _state.dicPos - wrPos);
+
+      if (_state.dicPos == _state.dicBufSize)
+        _state.dicPos = 0;
+      wrPos = _state.dicPos;
+      
+      RINOK(res2);
+
+      if (needStop)
+      {
+        if (res != 0)
+          return S_FALSE;
+
+        if (status == LZMA_STATUS_FINISHED_WITH_MARK)
+        {
+          if (FinishStream)
+            if (_outSizeDefined && _outSize != _outProcessed)
+              return S_FALSE;
+          return readRes;
+        }
+        
+        if (outFinished && status != LZMA_STATUS_NEEDS_MORE_INPUT)
+          if (!FinishStream || status == LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+            return readRes;
+          
+        return S_FALSE;
+      }
+    }
+    
+    if (progress)
+    {
+      const UInt64 inSize = _inProcessed - startInProgress;
+      RINOK(progress->SetRatioInfo(&inSize, &_outProcessed));
+    }
+  }
+}
+
+
+STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+  if (!_inBuf)
+    return E_INVALIDARG;
+  SetOutStreamSize(outSize);
+  HRESULT res = CodeSpec(inStream, outStream, progress);
+  if (res == S_OK)
+    if (FinishStream && inSize && *inSize != _inProcessed)
+      res = S_FALSE;
+  return res;
+}
+
+
+#ifndef NO_READ_FROM_CODER
+
+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { _inStream = inStream; return S_OK; }
+STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
+
+
+STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+
+  ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
+  if (_outSizeDefined)
+  {
+    const UInt64 rem = _outSize - _outProcessed;
+    if (size >= rem)
+    {
+      size = (UInt32)rem;
+      if (FinishStream)
+        finishMode = LZMA_FINISH_END;
+    }
+  }
+
+  HRESULT readRes = S_OK;
+  
+  for (;;)
+  {
+    if (_inPos == _inLim && readRes == S_OK)
+    {
+      _inPos = _inLim = 0;
+      readRes = _inStream->Read(_inBuf, _inBufSize, &_inLim);
+    }
+
+    SizeT inProcessed = _inLim - _inPos;
+    SizeT outProcessed = size;
+    ELzmaStatus status;
+    
+    SRes res = LzmaDec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
+        _inBuf + _inPos, &inProcessed, finishMode, &status);
+    
+    _lzmaStatus = status;
+    _inPos += (UInt32)inProcessed;
+    _inProcessed += inProcessed;
+    _outProcessed += outProcessed;
+    size -= (UInt32)outProcessed;
+    data = (Byte *)data + outProcessed;
+    if (processedSize)
+      *processedSize += (UInt32)outProcessed;
+
+    if (res != 0)
+      return S_FALSE;
+    
+    /*
+    if (status == LZMA_STATUS_FINISHED_WITH_MARK)
+      return readRes;
+
+    if (size == 0 && status != LZMA_STATUS_NEEDS_MORE_INPUT)
+    {
+      if (FinishStream
+          && _outSizeDefined && _outProcessed >= _outSize
+          && status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK)
+        return S_FALSE;
+      return readRes;
+    }
+    */
+
+    if (inProcessed == 0 && outProcessed == 0)
+      return readRes;
+  }
+}
+
+
+HRESULT CDecoder::CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress)
+{
+  SetOutStreamSizeResume(outSize);
+  return CodeSpec(_inStream, outStream, progress);
+}
+
+
+HRESULT CDecoder::ReadFromInputStream(void *data, UInt32 size, UInt32 *processedSize)
+{
+  RINOK(CreateInputBuffer());
+  
+  if (processedSize)
+    *processedSize = 0;
+
+  HRESULT readRes = S_OK;
+
+  while (size != 0)
+  {
+    if (_inPos == _inLim)
+    {
+      _inPos = _inLim = 0;
+      if (readRes == S_OK)
+        readRes = _inStream->Read(_inBuf, _inBufSize, &_inLim);
+      if (_inLim == 0)
+        break;
+    }
+
+    UInt32 cur = _inLim - _inPos;
+    if (cur > size)
+      cur = size;
+    memcpy(data, _inBuf + _inPos, cur);
+    _inPos += cur;
+    _inProcessed += cur;
+    size -= cur;
+    data = (Byte *)data + cur;
+    if (processedSize)
+      *processedSize += cur;
+  }
+  
+  return readRes;
+}
+
+#endif
+
+}}

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/LzmaDecoder.h

@@ -0,0 +1,113 @@
+// LzmaDecoder.h
+
+#ifndef __LZMA_DECODER_H
+#define __LZMA_DECODER_H
+
+// #include "../../../C/Alloc.h"
+#include "../../../C/LzmaDec.h"
+
+#include "../../Common/MyCom.h"
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NLzma {
+
+class CDecoder:
+  public ICompressCoder,
+  public ICompressSetDecoderProperties2,
+  public ICompressSetFinishMode,
+  public ICompressGetInStreamProcessedSize,
+  public ICompressSetBufSize,
+  #ifndef NO_READ_FROM_CODER
+  public ICompressSetInStream,
+  public ICompressSetOutStreamSize,
+  public ISequentialInStream,
+  #endif
+  public CMyUnknownImp
+{
+  Byte *_inBuf;
+  UInt32 _inPos;
+  UInt32 _inLim;
+ 
+  ELzmaStatus _lzmaStatus;
+
+public:
+  bool FinishStream; // set it before decoding, if you need to decode full LZMA stream
+
+private:
+  bool _propsWereSet;
+  bool _outSizeDefined;
+  UInt64 _outSize;
+  UInt64 _inProcessed;
+  UInt64 _outProcessed;
+
+  UInt32 _outStep;
+  UInt32 _inBufSize;
+  UInt32 _inBufSizeNew;
+
+  // CAlignOffsetAlloc _alloc;
+
+  CLzmaDec _state;
+
+  HRESULT CreateInputBuffer();
+  HRESULT CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *outStream, ICompressProgressInfo *progress);
+  void SetOutStreamSizeResume(const UInt64 *outSize);
+
+public:
+  MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetDecoderProperties2)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
+  MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetBufSize)
+  #ifndef NO_READ_FROM_CODER
+  MY_QUERYINTERFACE_ENTRY(ICompressSetInStream)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetOutStreamSize)
+  MY_QUERYINTERFACE_ENTRY(ISequentialInStream)
+  #endif
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
+
+  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
+  STDMETHOD(SetFinishMode)(UInt32 finishMode);
+  STDMETHOD(GetInStreamProcessedSize)(UInt64 *value);
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
+  STDMETHOD(SetInBufSize)(UInt32 streamIndex, UInt32 size);
+  STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
+
+  #ifndef NO_READ_FROM_CODER
+
+private:
+  CMyComPtr<ISequentialInStream> _inStream;
+public:
+  
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+
+  HRESULT CodeResume(ISequentialOutStream *outStream, const UInt64 *outSize, ICompressProgressInfo *progress);
+  HRESULT ReadFromInputStream(void *data, UInt32 size, UInt32 *processedSize);
+  
+  #endif
+
+  UInt64 GetInputProcessedSize() const { return _inProcessed; }
+
+  CDecoder();
+  virtual ~CDecoder();
+
+  UInt64 GetOutputProcessedSize() const { return _outProcessed; }
+
+  bool NeedsMoreInput() const { return _lzmaStatus == LZMA_STATUS_NEEDS_MORE_INPUT; }
+
+  bool CheckFinishStatus(bool withEndMark) const
+  {
+    return _lzmaStatus == (withEndMark ?
+        LZMA_STATUS_FINISHED_WITH_MARK :
+        LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK);
+  }
+};
+
+}}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/LzmaEncoder.cpp

@@ -0,0 +1,182 @@
+// LzmaEncoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/CWrappers.h"
+#include "../Common/StreamUtils.h"
+
+#include "LzmaEncoder.h"
+
+namespace NCompress {
+namespace NLzma {
+
+CEncoder::CEncoder()
+{
+  _encoder = NULL;
+  _encoder = LzmaEnc_Create(&g_AlignedAlloc);
+  if (!_encoder)
+    throw 1;
+}
+
+CEncoder::~CEncoder()
+{
+  if (_encoder)
+    LzmaEnc_Destroy(_encoder, &g_AlignedAlloc, &g_BigAlloc);
+}
+
+static inline wchar_t GetUpperChar(wchar_t c)
+{
+  if (c >= 'a' && c <= 'z')
+    c -= 0x20;
+  return c;
+}
+
+static int ParseMatchFinder(const wchar_t *s, int *btMode, int *numHashBytes)
+{
+  wchar_t c = GetUpperChar(*s++);
+  if (c == L'H')
+  {
+    if (GetUpperChar(*s++) != L'C')
+      return 0;
+    int numHashBytesLoc = (int)(*s++ - L'0');
+    if (numHashBytesLoc < 4 || numHashBytesLoc > 4)
+      return 0;
+    if (*s != 0)
+      return 0;
+    *btMode = 0;
+    *numHashBytes = numHashBytesLoc;
+    return 1;
+  }
+
+  if (c != L'B')
+    return 0;
+  if (GetUpperChar(*s++) != L'T')
+    return 0;
+  int numHashBytesLoc = (int)(*s++ - L'0');
+  if (numHashBytesLoc < 2 || numHashBytesLoc > 4)
+    return 0;
+  if (*s != 0)
+    return 0;
+  *btMode = 1;
+  *numHashBytes = numHashBytesLoc;
+  return 1;
+}
+
+#define SET_PROP_32(_id_, _dest_) case NCoderPropID::_id_: ep._dest_ = v; break;
+
+HRESULT SetLzmaProp(PROPID propID, const PROPVARIANT &prop, CLzmaEncProps &ep)
+{
+  if (propID == NCoderPropID::kMatchFinder)
+  {
+    if (prop.vt != VT_BSTR)
+      return E_INVALIDARG;
+    return ParseMatchFinder(prop.bstrVal, &ep.btMode, &ep.numHashBytes) ? S_OK : E_INVALIDARG;
+  }
+  
+  if (propID > NCoderPropID::kReduceSize)
+    return S_OK;
+  
+  if (propID == NCoderPropID::kReduceSize)
+  {
+    if (prop.vt == VT_UI8)
+      ep.reduceSize = prop.uhVal.QuadPart;
+    else
+      return E_INVALIDARG;
+    return S_OK;
+  }
+
+  if (prop.vt != VT_UI4)
+    return E_INVALIDARG;
+  UInt32 v = prop.ulVal;
+  switch (propID)
+  {
+    case NCoderPropID::kDefaultProp: if (v > 31) return E_INVALIDARG; ep.dictSize = (UInt32)1 << (unsigned)v; break;
+    SET_PROP_32(kLevel, level)
+    SET_PROP_32(kNumFastBytes, fb)
+    SET_PROP_32(kMatchFinderCycles, mc)
+    SET_PROP_32(kAlgorithm, algo)
+    SET_PROP_32(kDictionarySize, dictSize)
+    SET_PROP_32(kPosStateBits, pb)
+    SET_PROP_32(kLitPosBits, lp)
+    SET_PROP_32(kLitContextBits, lc)
+    SET_PROP_32(kNumThreads, numThreads)
+    default: return E_INVALIDARG;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs,
+    const PROPVARIANT *coderProps, UInt32 numProps)
+{
+  CLzmaEncProps props;
+  LzmaEncProps_Init(&props);
+
+  for (UInt32 i = 0; i < numProps; i++)
+  {
+    const PROPVARIANT &prop = coderProps[i];
+    PROPID propID = propIDs[i];
+    switch (propID)
+    {
+      case NCoderPropID::kEndMarker:
+        if (prop.vt != VT_BOOL) return E_INVALIDARG; props.writeEndMark = (prop.boolVal != VARIANT_FALSE); break;
+      default:
+        RINOK(SetLzmaProp(propID, prop, props));
+    }
+  }
+  return SResToHRESULT(LzmaEnc_SetProps(_encoder, &props));
+}
+
+
+STDMETHODIMP CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
+    const PROPVARIANT *coderProps, UInt32 numProps)
+{
+  for (UInt32 i = 0; i < numProps; i++)
+  {
+    const PROPVARIANT &prop = coderProps[i];
+    PROPID propID = propIDs[i];
+    if (propID == NCoderPropID::kExpectedDataSize)
+      if (prop.vt == VT_UI8)
+        LzmaEnc_SetDataSize(_encoder, prop.uhVal.QuadPart);
+  }
+  return S_OK;
+}
+
+
+STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
+{
+  Byte props[LZMA_PROPS_SIZE];
+  size_t size = LZMA_PROPS_SIZE;
+  RINOK(LzmaEnc_WriteProperties(_encoder, props, &size));
+  return WriteStream(outStream, props, size);
+}
+
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+  if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
+{
+  CSeqInStreamWrap inWrap;
+  CSeqOutStreamWrap outWrap;
+  CCompressProgressWrap progressWrap;
+
+  inWrap.Init(inStream);
+  outWrap.Init(outStream);
+  progressWrap.Init(progress);
+
+  SRes res = LzmaEnc_Encode(_encoder, &outWrap.vt, &inWrap.vt,
+      progress ? &progressWrap.vt : NULL, &g_AlignedAlloc, &g_BigAlloc);
+
+  _inputProcessed = inWrap.Processed;
+
+  RET_IF_WRAP_ERROR(inWrap.Res, res, SZ_ERROR_READ)
+  RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+  RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+  
+  return SResToHRESULT(res);
+}
+
+}}

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/LzmaEncoder.h

@@ -0,0 +1,46 @@
+// LzmaEncoder.h
+
+#ifndef __LZMA_ENCODER_H
+#define __LZMA_ENCODER_H
+
+#include "../../../C/LzmaEnc.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NLzma {
+
+class CEncoder:
+  public ICompressCoder,
+  public ICompressSetCoderProperties,
+  public ICompressWriteCoderProperties,
+  public ICompressSetCoderPropertiesOpt,
+  public CMyUnknownImp
+{
+  CLzmaEncHandle _encoder;
+  UInt64 _inputProcessed;
+public:
+  MY_UNKNOWN_IMP4(
+      ICompressCoder,
+      ICompressSetCoderProperties,
+      ICompressWriteCoderProperties,
+      ICompressSetCoderPropertiesOpt)
+    
+  STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+      const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+  STDMETHOD(WriteCoderProperties)(ISequentialOutStream *outStream);
+  STDMETHOD(SetCoderPropertiesOpt)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+
+  CEncoder();
+  virtual ~CEncoder();
+
+  UInt64 GetInputProcessedSize() const { return _inputProcessed; }
+  bool IsWriteEndMark() const { return LzmaEnc_IsWriteEndMark(_encoder) != 0; }
+};
+
+}}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Compress/LzmaRegister.cpp

@@ -0,0 +1,22 @@
+// LzmaRegister.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/RegisterCodec.h"
+
+#include "LzmaDecoder.h"
+
+#ifndef EXTRACT_ONLY
+#include "LzmaEncoder.h"
+#endif
+
+namespace NCompress {
+namespace NLzma {
+
+REGISTER_CODEC_E(LZMA,
+    CDecoder(),
+    CEncoder(),
+    0x30101,
+    "LZMA")
+
+}}