react-native-update 10.34.3 → 10.34.5

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

@@ -1,4 +1,5 @@
 // PpmdDecoder.cpp
+// 2009-03-11 : Igor Pavlov : Public domain
 
 #include "StdAfx.h"
 
@@ -12,13 +13,13 @@
 namespace NCompress {
 namespace NPpmd {
 
-static const UInt32 kBufSize = (1 << 16);
+static const UInt32 kBufSize = (1 << 20);
 
 enum
 {
   kStatus_NeedInit,
   kStatus_Normal,
-  kStatus_Finished_With_Mark,
+  kStatus_Finished,
   kStatus_Error
 };
 
@@ -28,12 +29,12 @@ CDecoder::~CDecoder()
   Ppmd7_Free(&_ppmd, &g_BigAlloc);
 }
 
-Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size))
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size)
 {
   if (size < 5)
     return E_INVALIDARG;
   _order = props[0];
-  const UInt32 memSize = GetUi32(props + 1);
+  UInt32 memSize = GetUi32(props + 1);
   if (_order < PPMD7_MIN_ORDER ||
       _order > PPMD7_MAX_ORDER ||
       memSize < PPMD7_MIN_MEM_SIZE ||
@@ -46,37 +47,23 @@ Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *props, UInt32 size))
   return S_OK;
 }
 
-#define MY_rangeDec  _ppmd.rc.dec
-
-#define CHECK_EXTRA_ERROR \
-    if (_inStream.Extra) { \
-      _status = kStatus_Error; \
-      return (_res = (_inStream.Res != SZ_OK ? _inStream.Res: S_FALSE)); }
-
-
 HRESULT CDecoder::CodeSpec(Byte *memStream, UInt32 size)
 {
-  if (_res != S_OK)
-    return _res;
-  
   switch (_status)
   {
-    case kStatus_Finished_With_Mark: return S_OK;
+    case kStatus_Finished: return S_OK;
     case kStatus_Error: return S_FALSE;
     case kStatus_NeedInit:
       _inStream.Init();
-      if (!Ppmd7z_RangeDec_Init(&MY_rangeDec))
+      if (!Ppmd7z_RangeDec_Init(&_rangeDec))
       {
         _status = kStatus_Error;
-        return (_res = S_FALSE);
+        return S_FALSE;
       }
-      CHECK_EXTRA_ERROR
       _status = kStatus_Normal;
       Ppmd7_Init(&_ppmd, _order);
       break;
-    default: break;
   }
-  
   if (_outSizeDefined)
   {
     const UInt64 rem = _outSize - _processedSize;
@@ -84,54 +71,29 @@ HRESULT CDecoder::CodeSpec(Byte *memStream, UInt32 size)
       size = (UInt32)rem;
   }
 
+  UInt32 i;
   int sym = 0;
+  for (i = 0; i != size; i++)
   {
-    Byte *buf = memStream;
-    const Byte *lim = buf + size;
-    for (; buf != lim; buf++)
-    {
-      sym = Ppmd7z_DecodeSymbol(&_ppmd);
-      if (_inStream.Extra || sym < 0)
-        break;
-      *buf = (Byte)sym;
-    }
-    /*
-    buf = Ppmd7z_DecodeSymbols(&_ppmd, buf, lim);
-    sym = _ppmd.LastSymbol;
-    */
-    _processedSize += (size_t)(buf - memStream);
-  }
-
-  CHECK_EXTRA_ERROR
-  
-  if (sym >= 0)
-  {
-    if (!FinishStream
-        || !_outSizeDefined
-        || _outSize != _processedSize
-        || MY_rangeDec.Code == 0)
-      return S_OK;
-    /*
-    // We can decode additional End Marker here:
-    sym = Ppmd7z_DecodeSymbol(&_ppmd);
-    CHECK_EXTRA_ERROR
-    */
+    sym = Ppmd7_DecodeSymbol(&_ppmd, &_rangeDec.vt);
+    if (_inStream.Extra || sym < 0)
+      break;
+    memStream[i] = (Byte)sym;
   }
 
-  if (sym != PPMD7_SYM_END || MY_rangeDec.Code != 0)
+  _processedSize += i;
+  if (_inStream.Extra)
   {
     _status = kStatus_Error;
-    return (_res = S_FALSE);
+    return _inStream.Res;
   }
-  
-  _status = kStatus_Finished_With_Mark;
+  if (sym < 0)
+    _status = (sym < -1) ? kStatus_Error : kStatus_Finished;
   return S_OK;
 }
 
-
-
-Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-    const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress))
+STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
 {
   if (!_outBuf)
   {
@@ -146,69 +108,58 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   do
   {
     const UInt64 startPos = _processedSize;
-    const HRESULT res = CodeSpec(_outBuf, kBufSize);
-    const size_t processed = (size_t)(_processedSize - startPos);
-    RINOK(WriteStream(outStream, _outBuf, processed))
-    RINOK(res)
-    if (_status == kStatus_Finished_With_Mark)
+    HRESULT res = CodeSpec(_outBuf, kBufSize);
+    size_t processed = (size_t)(_processedSize - startPos);
+    RINOK(WriteStream(outStream, _outBuf, processed));
+    RINOK(res);
+    if (_status == kStatus_Finished)
       break;
     if (progress)
     {
-      const UInt64 inProcessed = _inStream.GetProcessed();
-      RINOK(progress->SetRatioInfo(&inProcessed, &_processedSize))
+      UInt64 inSize = _inStream.GetProcessed();
+      RINOK(progress->SetRatioInfo(&inSize, &_processedSize));
     }
   }
   while (!_outSizeDefined || _processedSize < _outSize);
-
-  if (FinishStream && inSize && *inSize != _inStream.GetProcessed())
-    return S_FALSE;
-
   return S_OK;
 }
 
-
-Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
 {
   _outSizeDefined = (outSize != NULL);
   if (_outSizeDefined)
     _outSize = *outSize;
   _processedSize = 0;
   _status = kStatus_NeedInit;
-  _res = SZ_OK;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
-{
-  FinishStream = (finishMode != 0);
-  return S_OK;
-}
 
-Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
 {
   *value = _inStream.GetProcessed();
   return S_OK;
 }
 
-#ifndef Z7_NO_READ_FROM_CODER
+#ifndef NO_READ_FROM_CODER
 
-Z7_COM7F_IMF(CDecoder::SetInStream(ISequentialInStream *inStream))
+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream)
 {
   InSeqStream = inStream;
   _inStream.Stream = inStream;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CDecoder::ReleaseInStream())
+STDMETHODIMP CDecoder::ReleaseInStream()
 {
   InSeqStream.Release();
   return S_OK;
 }
 
-Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   const UInt64 startPos = _processedSize;
-  const HRESULT res = CodeSpec((Byte *)data, size);
+  HRESULT res = CodeSpec((Byte *)data, size);
   if (processedSize)
     *processedSize = (UInt32)(_processedSize - startPos);
   return res;

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

@@ -1,63 +1,38 @@
 // PpmdDecoder.h
+// 2009-03-11 : Igor Pavlov : Public domain
 
-#ifndef ZIP7_INC_COMPRESS_PPMD_DECODER_H
-#define ZIP7_INC_COMPRESS_PPMD_DECODER_H
+#ifndef __COMPRESS_PPMD_DECODER_H
+#define __COMPRESS_PPMD_DECODER_H
 
 #include "../../../C/Ppmd7.h"
 
 #include "../../Common/MyCom.h"
 
-#include "../ICoder.h"
-
 #include "../Common/CWrappers.h"
 
+#include "../ICoder.h"
+
 namespace NCompress {
 namespace NPpmd {
 
-class CDecoder Z7_final:
+class CDecoder :
   public ICompressCoder,
   public ICompressSetDecoderProperties2,
-  public ICompressSetFinishMode,
   public ICompressGetInStreamProcessedSize,
- #ifndef Z7_NO_READ_FROM_CODER
+  #ifndef NO_READ_FROM_CODER
   public ICompressSetInStream,
   public ICompressSetOutStreamSize,
   public ISequentialInStream,
- #endif
+  #endif
   public CMyUnknownImp
 {
-  Z7_COM_QI_BEGIN2(ICompressCoder)
-  Z7_COM_QI_ENTRY(ICompressSetDecoderProperties2)
-  Z7_COM_QI_ENTRY(ICompressSetFinishMode)
-  Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
- #ifndef Z7_NO_READ_FROM_CODER
-  Z7_COM_QI_ENTRY(ICompressSetInStream)
-  Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
-  Z7_COM_QI_ENTRY(ISequentialInStream)
- #endif
-  Z7_COM_QI_END
-  Z7_COM_ADDREF_RELEASE
-
-  Z7_IFACE_COM7_IMP(ICompressCoder)
-  Z7_IFACE_COM7_IMP(ICompressSetDecoderProperties2)
-  Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
-  Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
- #ifndef Z7_NO_READ_FROM_CODER
-  Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
-  Z7_IFACE_COM7_IMP(ICompressSetInStream)
-  Z7_IFACE_COM7_IMP(ISequentialInStream)
- #else
-  Z7_COM7F_IMF(SetOutStreamSize(const UInt64 *outSize));
- #endif
-
   Byte *_outBuf;
+  CPpmd7z_RangeDec _rangeDec;
   CByteInBufWrap _inStream;
   CPpmd7 _ppmd;
 
   Byte _order;
-  bool  FinishStream;
   bool _outSizeDefined;
-  HRESULT _res;
   int _status;
   UInt64 _outSize;
   UInt64 _processedSize;
@@ -66,17 +41,41 @@ class CDecoder Z7_final:
 
 public:
 
- #ifndef Z7_NO_READ_FROM_CODER
+  #ifndef NO_READ_FROM_CODER
   CMyComPtr<ISequentialInStream> InSeqStream;
- #endif
-
-  CDecoder():
-      _outBuf(NULL),
-      FinishStream(false),
-      _outSizeDefined(false)
+  #endif
+
+  MY_QUERYINTERFACE_BEGIN2(ICompressCoder)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetDecoderProperties2)
+  // MY_QUERYINTERFACE_ENTRY(ICompressSetFinishMode)
+  MY_QUERYINTERFACE_ENTRY(ICompressGetInStreamProcessedSize)
+  #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(GetInStreamProcessedSize)(UInt64 *value);
+  
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
+
+  #ifndef NO_READ_FROM_CODER
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  #endif
+
+  CDecoder(): _outBuf(NULL), _outSizeDefined(false)
   {
+    Ppmd7z_RangeDec_CreateVTable(&_rangeDec);
+    _rangeDec.Stream = &_inStream.vt;
     Ppmd7_Construct(&_ppmd);
-    _ppmd.rc.dec.Stream = &_inStream.vt;
   }
 
   ~CDecoder();

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

@@ -3,6 +3,7 @@
 #include "StdAfx.h"
 
 #include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
 
 #include "../Common/StreamUtils.h"
 
@@ -20,11 +21,11 @@ void CEncProps::Normalize(int level)
   if (level < 0) level = 5;
   if (level > 9) level = 9;
   if (MemSize == (UInt32)(Int32)-1)
-    MemSize = (UInt32)1 << (level + 19);
+    MemSize = level >= 9 ? ((UInt32)192 << 20) : ((UInt32)1 << (level + 19));
   const unsigned kMult = 16;
   if (MemSize / kMult > ReduceSize)
   {
-    for (unsigned i = 16; i < 32; i++)
+    for (unsigned i = 16; i <= 31; i++)
     {
       UInt32 m = (UInt32)1 << i;
       if (ReduceSize <= m / kMult)
@@ -42,8 +43,8 @@ CEncoder::CEncoder():
   _inBuf(NULL)
 {
   _props.Normalize(-1);
+  _rangeEnc.Stream = &_outStream.vt;
   Ppmd7_Construct(&_ppmd);
-  _ppmd.rc.enc.Stream = &_outStream.vt;
 }
 
 CEncoder::~CEncoder()
@@ -52,14 +53,14 @@ CEncoder::~CEncoder()
   Ppmd7_Free(&_ppmd, &g_BigAlloc);
 }
 
-Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
 {
   int level = -1;
   CEncProps props;
   for (UInt32 i = 0; i < numProps; i++)
   {
     const PROPVARIANT &prop = coderProps[i];
-    const PROPID propID = propIDs[i];
+    PROPID propID = propIDs[i];
     if (propID > NCoderPropID::kReduceSize)
       continue;
     if (propID == NCoderPropID::kReduceSize)
@@ -68,50 +69,16 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
         props.ReduceSize = (UInt32)prop.uhVal.QuadPart;
       continue;
     }
-
-    if (propID == NCoderPropID::kUsedMemorySize)
-    {
-      // here we have selected (4 GiB - 1 KiB) as replacement for (4 GiB) MEM_SIZE.
-      const UInt32 kPpmd_Default_4g = (UInt32)0 - ((UInt32)1 << 10);
-      UInt32 v;
-      if (prop.vt == VT_UI8)
-      {
-        // 21.03 : we support 64-bit values (for 4 GiB value)
-        const UInt64 v64 = prop.uhVal.QuadPart;
-        if (v64 > ((UInt64)1 << 32))
-          return E_INVALIDARG;
-        if (v64 == ((UInt64)1 << 32))
-          v = kPpmd_Default_4g;
-        else
-          v = (UInt32)v64;
-      }
-      else if (prop.vt == VT_UI4)
-        v = (UInt32)prop.ulVal;
-      else
-        return E_INVALIDARG;
-      if (v > PPMD7_MAX_MEM_SIZE)
-        v = kPpmd_Default_4g;
-
-      /* here we restrict MEM_SIZE for Encoder.
-         It's for better performance of encoding and decoding.
-         The Decoder still supports more MEM_SIZE values. */
-      if (v < ((UInt32)1 << 16) || (v & 3) != 0)
-        return E_INVALIDARG;
-      // if (v < PPMD7_MIN_MEM_SIZE) return E_INVALIDARG; // (1 << 11)
-      /*
-        Supported MEM_SIZE range :
-        [ (1 << 11) , 0xFFFFFFFF - 12 * 3 ] - current 7-Zip's Ppmd7 constants
-        [ 1824      , 0xFFFFFFFF          ] - real limits of Ppmd7 code
-      */
-      props.MemSize = v;
-      continue;
-    }
-
     if (prop.vt != VT_UI4)
       return E_INVALIDARG;
-    const UInt32 v = (UInt32)prop.ulVal;
+    UInt32 v = (UInt32)prop.ulVal;
     switch (propID)
     {
+      case NCoderPropID::kUsedMemorySize:
+        if (v < (1 << 16) || v > PPMD7_MAX_MEM_SIZE || (v & 3) != 0)
+          return E_INVALIDARG;
+        props.MemSize = v;
+        break;
       case NCoderPropID::kOrder:
         if (v < 2 || v > 32)
           return E_INVALIDARG;
@@ -127,17 +94,17 @@ Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs, const PROPVARIA
   return S_OK;
 }
 
-Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
 {
   const UInt32 kPropSize = 5;
   Byte props[kPropSize];
   props[0] = (Byte)_props.Order;
-  SetUi32(props + 1, _props.MemSize)
+  SetUi32(props + 1, _props.MemSize);
   return WriteStream(outStream, props, kPropSize);
 }
 
-Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-    const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+HRESULT CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
 {
   if (!_inBuf)
   {
@@ -153,39 +120,31 @@ Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   _outStream.Stream = outStream;
   _outStream.Init();
 
-  Ppmd7z_Init_RangeEnc(&_ppmd);
-  Ppmd7_Init(&_ppmd, (unsigned)_props.Order);
+  Ppmd7z_RangeEnc_Init(&_rangeEnc);
+  Ppmd7_Init(&_ppmd, _props.Order);
 
   UInt64 processed = 0;
   for (;;)
   {
     UInt32 size;
-    RINOK(inStream->Read(_inBuf, kBufSize, &size))
+    RINOK(inStream->Read(_inBuf, kBufSize, &size));
     if (size == 0)
     {
       // We don't write EndMark in PPMD-7z.
-      // Ppmd7z_EncodeSymbol(&_ppmd, -1);
-      Ppmd7z_Flush_RangeEnc(&_ppmd);
+      // Ppmd7_EncodeSymbol(&_ppmd, &_rangeEnc, -1);
+      Ppmd7z_RangeEnc_FlushData(&_rangeEnc);
       return _outStream.Flush();
     }
-    const Byte *buf = _inBuf;
-    const Byte *lim = buf + size;
-    /*
-    for (; buf < lim; buf++)
+    for (UInt32 i = 0; i < size; i++)
     {
-      Ppmd7z_EncodeSymbol(&_ppmd, *buf);
+      Ppmd7_EncodeSymbol(&_ppmd, &_rangeEnc, _inBuf[i]);
       RINOK(_outStream.Res);
     }
-    */
-
-    Ppmd7z_EncodeSymbols(&_ppmd, buf, lim);
-    RINOK(_outStream.Res)
-
     processed += size;
     if (progress)
     {
-      const UInt64 outSize = _outStream.GetProcessed();
-      RINOK(progress->SetRatioInfo(&processed, &outSize))
+      UInt64 outSize = _outStream.GetProcessed();
+      RINOK(progress->SetRatioInfo(&processed, &outSize));
     }
   }
 }

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

@@ -1,7 +1,7 @@
 // PpmdEncoder.h
 
-#ifndef ZIP7_INC_COMPRESS_PPMD_ENCODER_H
-#define ZIP7_INC_COMPRESS_PPMD_ENCODER_H
+#ifndef __COMPRESS_PPMD_ENCODER_H
+#define __COMPRESS_PPMD_ENCODER_H
 
 #include "../../../C/Ppmd7.h"
 
@@ -29,17 +29,26 @@ struct CEncProps
   void Normalize(int level);
 };
 
-Z7_CLASS_IMP_COM_3(
-  CEncoder
-  , ICompressCoder
-  , ICompressSetCoderProperties
-  , ICompressWriteCoderProperties
-)
+class CEncoder :
+  public ICompressCoder,
+  public ICompressSetCoderProperties,
+  public ICompressWriteCoderProperties,
+  public CMyUnknownImp
+{
   Byte *_inBuf;
   CByteOutBufWrap _outStream;
+  CPpmd7z_RangeEnc _rangeEnc;
   CPpmd7 _ppmd;
   CEncProps _props;
 public:
+  MY_UNKNOWN_IMP3(
+      ICompressCoder,
+      ICompressSetCoderProperties,
+      ICompressWriteCoderProperties)
+  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);
   CEncoder();
   ~CEncoder();
 };

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

@@ -6,7 +6,7 @@
 
 #include "PpmdDecoder.h"
 
-#ifndef Z7_EXTRACT_ONLY
+#ifndef EXTRACT_ONLY
 #include "PpmdEncoder.h"
 #endif
 

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

@@ -1,11 +1,8 @@
 // StdAfx.h
 
-#ifndef ZIP7_INC_STDAFX_H
-#define ZIP7_INC_STDAFX_H
+#ifndef __STDAFX_H
+#define __STDAFX_H
 
-#if defined(_MSC_VER) && _MSC_VER >= 1800
-#pragma warning(disable : 4464) // relative include path contains '..'
-#endif
 #include "../../Common/Common.h"
 
 #endif

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

@@ -26,7 +26,6 @@ static HRESULT SResToHRESULT_Code(SRes res) throw()
     case SZ_OK: return S_OK;
     case SZ_ERROR_MEM: return E_OUTOFMEMORY;
     case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
-    default: break;
   }
   return S_FALSE;
 }
@@ -35,7 +34,7 @@ static HRESULT SResToHRESULT_Code(SRes res) throw()
 HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
     const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *progress)
 {
-  MainDecodeSRes = SZ_OK;
+  MainDecodeSRes = S_OK;
   MainDecodeSRes_wasUsed = false;
   XzStatInfo_Clear(&Stat);
 
@@ -51,10 +50,10 @@ HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream
 
   int isMT = False;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   {
     props.numThreads = 1;
-    const UInt32 numThreads = _numThreads;
+    UInt32 numThreads = _numThreads;
 
     if (_tryMt && numThreads > 1)
     {
@@ -88,7 +87,7 @@ HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream
 
   MainDecodeSRes = res;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   // _tryMt = isMT;
   #endif
 
@@ -96,7 +95,7 @@ HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream
   RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
   RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
 
-  // return E_OUTOFMEMORY; // for debug check
+  // return E_OUTOFMEMORY;
 
   MainDecodeSRes_wasUsed = true;
 
@@ -114,33 +113,33 @@ HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream
 }
 
 
-Z7_COM7F_IMF(CComDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-    const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+HRESULT CComDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress)
 {
   return Decode(inStream, outStream, outSize, _finishStream, progress);
 }
 
-Z7_COM7F_IMF(CComDecoder::SetFinishMode(UInt32 finishMode))
+STDMETHODIMP CComDecoder::SetFinishMode(UInt32 finishMode)
 {
   _finishStream = (finishMode != 0);
   return S_OK;
 }
 
-Z7_COM7F_IMF(CComDecoder::GetInStreamProcessedSize(UInt64 *value))
+STDMETHODIMP CComDecoder::GetInStreamProcessedSize(UInt64 *value)
 {
   *value = Stat.InSize;
   return S_OK;
 }
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
-Z7_COM7F_IMF(CComDecoder::SetNumberOfThreads(UInt32 numThreads))
+STDMETHODIMP CComDecoder::SetNumberOfThreads(UInt32 numThreads)
 {
   _numThreads = numThreads;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CComDecoder::SetMemLimit(UInt64 memUsage))
+STDMETHODIMP CComDecoder::SetMemLimit(UInt64 memUsage)
 {
   _memUsage = memUsage;
   return S_OK;