react-native-update 10.28.10 → 10.29.0-beta.0

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

@@ -1,343 +0,0 @@
-// 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/src/main/cpp/lzma/CPP/7zip/Compress/LzmaDecoder.h

@@ -1,113 +0,0 @@
-// 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/src/main/cpp/lzma/CPP/7zip/Compress/LzmaEncoder.cpp

@@ -1,182 +0,0 @@
-// 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/src/main/cpp/lzma/CPP/7zip/Compress/LzmaEncoder.h

@@ -1,46 +0,0 @@
-// 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/src/main/cpp/lzma/CPP/7zip/Compress/LzmaRegister.cpp

@@ -1,22 +0,0 @@
-// 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")
-
-}}