react-native-update 10.34.3 → 10.34.4

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

@@ -21,7 +21,7 @@ CDecoder::CDecoder():
     , _finishMode(false)
     , _inBufSize(1 << 20)
     , _outStep(1 << 20)
-    #ifndef Z7_ST
+    #ifndef _7ZIP_ST
     , _tryMt(1)
     , _numThreads(1)
     , _memUsage((UInt64)(sizeof(size_t)) << 28)
@@ -34,10 +34,10 @@ CDecoder::~CDecoder()
     Lzma2DecMt_Destroy(_dec);
 }
 
-Z7_COM7F_IMF(CDecoder::SetInBufSize(UInt32 , UInt32 size)) { _inBufSize = size; return S_OK; }
-Z7_COM7F_IMF(CDecoder::SetOutBufSize(UInt32 , UInt32 size)) { _outStep = size; return S_OK; }
+STDMETHODIMP CDecoder::SetInBufSize(UInt32 , UInt32 size) { _inBufSize = size; return S_OK; }
+STDMETHODIMP CDecoder::SetOutBufSize(UInt32 , UInt32 size) { _outStep = size; return S_OK; }
 
-Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size))
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
 {
   if (size != 1)
     return E_NOTIMPL;
@@ -48,7 +48,7 @@ Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size))
 }
 
 
-Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
 {
   _finishMode = (finishMode != 0);
   return S_OK;
@@ -56,7 +56,7 @@ Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
 
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
 static UInt64 Get_ExpectedBlockSize_From_Dict(UInt32 dictSize)
 {
@@ -81,8 +81,8 @@ static UInt64 Get_ExpectedBlockSize_From_Dict(UInt32 dictSize)
 #define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
   if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
 
-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)
 {
   _inProcessed = 0;
 
@@ -102,24 +102,24 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   props.inBufSize_ST = _inBufSize;
   props.outStep_ST = _outStep;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   {
     props.numThreads = 1;
     UInt32 numThreads = _numThreads;
 
     if (_tryMt && numThreads >= 1)
     {
-      const UInt64 useLimit = _memUsage;
-      const UInt32 dictSize = LZMA2_DIC_SIZE_FROM_PROP_FULL(_prop);
-      const UInt64 expectedBlockSize64 = Get_ExpectedBlockSize_From_Dict(dictSize);
-      const size_t expectedBlockSize = (size_t)expectedBlockSize64;
-      const size_t inBlockMax = expectedBlockSize + expectedBlockSize / 16;
+      UInt64 useLimit = _memUsage;
+      UInt32 dictSize = LZMA2_DIC_SIZE_FROM_PROP_FULL(_prop);
+      UInt64 expectedBlockSize64 = Get_ExpectedBlockSize_From_Dict(dictSize);
+      size_t expectedBlockSize = (size_t)expectedBlockSize64;
+      size_t inBlockMax = expectedBlockSize + expectedBlockSize / 16;
       if (expectedBlockSize == expectedBlockSize64 && inBlockMax >= expectedBlockSize)
       {
         props.outBlockMax = expectedBlockSize;
         props.inBlockMax = inBlockMax;
         const size_t kOverheadSize = props.inBufSize_MT + (1 << 16);
-        const UInt64 okThreads = useLimit / (props.outBlockMax + props.inBlockMax + kOverheadSize);
+        UInt64 okThreads = useLimit / (props.outBlockMax + props.inBlockMax + kOverheadSize);
         if (numThreads > okThreads)
           numThreads = (UInt32)okThreads;
         if (numThreads == 0)
@@ -143,7 +143,7 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   UInt64 inProcessed = 0;
   int isMT = False;
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   isMT = _tryMt;
   #endif
 
@@ -162,7 +162,7 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   */
 
 
-  #ifndef Z7_ST
+  #ifndef _7ZIP_ST
   /* we reset _tryMt, only if p->props.numThreads was changed */
   if (props.numThreads > 1)
     _tryMt = isMT;
@@ -186,22 +186,22 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
 }
 
 
-Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
 {
   *value = _inProcessed;
   return S_OK;
 }
 
 
-#ifndef Z7_ST
+#ifndef _7ZIP_ST
 
-Z7_COM7F_IMF(CDecoder::SetNumberOfThreads(UInt32 numThreads))
+STDMETHODIMP CDecoder::SetNumberOfThreads(UInt32 numThreads)
 {
   _numThreads = numThreads;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CDecoder::SetMemLimit(UInt64 memUsage))
+STDMETHODIMP CDecoder::SetMemLimit(UInt64 memUsage)
 {
   _memUsage = memUsage;
   return S_OK;
@@ -210,9 +210,9 @@ Z7_COM7F_IMF(CDecoder::SetMemLimit(UInt64 memUsage))
 #endif
 
 
-#ifndef Z7_NO_READ_FROM_CODER
+#ifndef NO_READ_FROM_CODER
 
-Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
 {
   CLzma2DecMtProps props;
   Lzma2DecMtProps_Init(&props);
@@ -230,7 +230,7 @@ Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
 
   _inWrap.Init(_inStream);
 
-  const SRes res = Lzma2DecMt_Init(_dec, _prop, &props, outSize, _finishMode, &_inWrap.vt);
+  SRes res = Lzma2DecMt_Init(_dec, _prop, &props, outSize, _finishMode, &_inWrap.vt);
 
   if (res != SZ_OK)
     return SResToHRESULT(res);
@@ -238,13 +238,11 @@ Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
 }
 
 
-Z7_COM7F_IMF(CDecoder::SetInStream(ISequentialInStream *inStream))
-  { _inStream = inStream; return S_OK; }
-Z7_COM7F_IMF(CDecoder::ReleaseInStream())
-  { _inStream.Release(); return S_OK; }
+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { _inStream = inStream; return S_OK; }
+STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
   
 
-Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -252,7 +250,7 @@ Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
   size_t size2 = size;
   UInt64 inProcessed = 0;
 
-  const SRes res = Lzma2DecMt_Read(_dec, (Byte *)data, &size2, &inProcessed);
+  SRes res = Lzma2DecMt_Read(_dec, (Byte *)data, &size2, &inProcessed);
 
   _inProcessed += inProcessed;
   if (processedSize)

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

@@ -1,7 +1,7 @@
 // Lzma2Decoder.h
 
-#ifndef ZIP7_INC_LZMA2_DECODER_H
-#define ZIP7_INC_LZMA2_DECODER_H
+#ifndef __LZMA2_DECODER_H
+#define __LZMA2_DECODER_H
 
 #include "../../../C/Lzma2DecMt.h"
 
@@ -10,55 +10,26 @@
 namespace NCompress {
 namespace NLzma2 {
 
-class CDecoder Z7_final:
+class CDecoder:
   public ICompressCoder,
   public ICompressSetDecoderProperties2,
   public ICompressSetFinishMode,
   public ICompressGetInStreamProcessedSize,
   public ICompressSetBufSize,
- #ifndef Z7_NO_READ_FROM_CODER
+
+  #ifndef NO_READ_FROM_CODER
   public ICompressSetInStream,
   public ICompressSetOutStreamSize,
   public ISequentialInStream,
- #endif
- #ifndef Z7_ST
+  #endif
+
+  #ifndef _7ZIP_ST
   public ICompressSetCoderMt,
   public ICompressSetMemLimit,
- #endif
+  #endif
+
   public CMyUnknownImp
 {
-  Z7_COM_QI_BEGIN2(ICompressCoder)
-  Z7_COM_QI_ENTRY(ICompressSetDecoderProperties2)
-  Z7_COM_QI_ENTRY(ICompressSetFinishMode)
-  Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
-  Z7_COM_QI_ENTRY(ICompressSetBufSize)
- #ifndef Z7_NO_READ_FROM_CODER
-  Z7_COM_QI_ENTRY(ICompressSetInStream)
-  Z7_COM_QI_ENTRY(ICompressSetOutStreamSize)
-  Z7_COM_QI_ENTRY(ISequentialInStream)
- #endif
- #ifndef Z7_ST
-  Z7_COM_QI_ENTRY(ICompressSetCoderMt)
-  Z7_COM_QI_ENTRY(ICompressSetMemLimit)
- #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)
-  Z7_IFACE_COM7_IMP(ICompressSetBufSize)
- #ifndef Z7_NO_READ_FROM_CODER
-  Z7_IFACE_COM7_IMP(ICompressSetOutStreamSize)
-  Z7_IFACE_COM7_IMP(ICompressSetInStream)
-  Z7_IFACE_COM7_IMP(ISequentialInStream)
- #endif
- #ifndef Z7_ST
-  Z7_IFACE_COM7_IMP(ICompressSetCoderMt)
-  Z7_IFACE_COM7_IMP(ICompressSetMemLimit)
- #endif
-
   CLzma2DecMtHandle _dec;
   UInt64 _inProcessed;
   Byte _prop;
@@ -66,20 +37,58 @@ class CDecoder Z7_final:
   UInt32 _inBufSize;
   UInt32 _outStep;
 
- #ifndef Z7_ST
+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
+  
+  #ifndef _7ZIP_ST
+  MY_QUERYINTERFACE_ENTRY(ICompressSetCoderMt)
+  MY_QUERYINTERFACE_ENTRY(ICompressSetMemLimit)
+  #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(SetInBufSize)(UInt32 streamIndex, UInt32 size);
+  STDMETHOD(SetOutBufSize)(UInt32 streamIndex, UInt32 size);
+
+  #ifndef _7ZIP_ST
+private:
   int _tryMt;
   UInt32 _numThreads;
   UInt64 _memUsage;
- #endif
+public:
+  STDMETHOD(SetNumberOfThreads)(UInt32 numThreads);
+  STDMETHOD(SetMemLimit)(UInt64 memUsage);
+  #endif
 
- #ifndef Z7_NO_READ_FROM_CODER
+  #ifndef NO_READ_FROM_CODER
+private:
   CMyComPtr<ISequentialInStream> _inStream;
   CSeqInStreamWrap _inWrap;
- #endif
-
 public:
+  STDMETHOD(SetOutStreamSize)(const UInt64 *outSize);
+  STDMETHOD(SetInStream)(ISequentialInStream *inStream);
+  STDMETHOD(ReleaseInStream)();
+  STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
+  #endif
+
   CDecoder();
-  ~CDecoder();
+  virtual ~CDecoder();
 };
 
 }}

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

@@ -34,7 +34,6 @@ CEncoder::~CEncoder()
 }
 
 
-HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzma2Props);
 HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzma2Props)
 {
   switch (propID)
@@ -50,46 +49,35 @@ HRESULT SetLzma2Prop(PROPID propID, const PROPVARIANT &prop, CLzma2EncProps &lzm
       break;
     }
     case NCoderPropID::kNumThreads:
-      if (prop.vt != VT_UI4)
-        return E_INVALIDARG;
-      lzma2Props.numTotalThreads = (int)prop.ulVal;
-      break;
-    case NCoderPropID::kNumThreadGroups:
-      if (prop.vt != VT_UI4)
-        return E_INVALIDARG;
-      // 16-bit value supported by Windows
-      if (prop.ulVal >= (1u << 16))
-        return E_INVALIDARG;
-      lzma2Props.numThreadGroups = (unsigned)prop.ulVal;
-      break;
+      if (prop.vt != VT_UI4) return E_INVALIDARG; lzma2Props.numTotalThreads = (int)(prop.ulVal); break;
     default:
-      RINOK(NLzma::SetLzmaProp(propID, prop, lzma2Props.lzmaProps))
+      RINOK(NLzma::SetLzmaProp(propID, prop, lzma2Props.lzmaProps));
   }
   return S_OK;
 }
 
 
-Z7_COM7F_IMF(CEncoder::SetCoderProperties(const PROPID *propIDs,
-    const PROPVARIANT *coderProps, UInt32 numProps))
+STDMETHODIMP CEncoder::SetCoderProperties(const PROPID *propIDs,
+    const PROPVARIANT *coderProps, UInt32 numProps)
 {
   CLzma2EncProps lzma2Props;
   Lzma2EncProps_Init(&lzma2Props);
 
   for (UInt32 i = 0; i < numProps; i++)
   {
-    RINOK(SetLzma2Prop(propIDs[i], coderProps[i], lzma2Props))
+    RINOK(SetLzma2Prop(propIDs[i], coderProps[i], lzma2Props));
   }
   return SResToHRESULT(Lzma2Enc_SetProps(_encoder, &lzma2Props));
 }
 
 
-Z7_COM7F_IMF(CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
-    const PROPVARIANT *coderProps, UInt32 numProps))
+STDMETHODIMP CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
+    const PROPVARIANT *coderProps, UInt32 numProps)
 {
   for (UInt32 i = 0; i < numProps; i++)
   {
     const PROPVARIANT &prop = coderProps[i];
-    const PROPID propID = propIDs[i];
+    PROPID propID = propIDs[i];
     if (propID == NCoderPropID::kExpectedDataSize)
       if (prop.vt == VT_UI8)
         Lzma2Enc_SetDataSize(_encoder, prop.uhVal.QuadPart);
@@ -98,9 +86,9 @@ Z7_COM7F_IMF(CEncoder::SetCoderPropertiesOpt(const PROPID *propIDs,
 }
 
 
-Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
+STDMETHODIMP CEncoder::WriteCoderProperties(ISequentialOutStream *outStream)
 {
-  const Byte prop = Lzma2Enc_WriteProperties(_encoder);
+  Byte prop = Lzma2Enc_WriteProperties(_encoder);
   return WriteStream(outStream, &prop, 1);
 }
 
@@ -108,8 +96,8 @@ Z7_COM7F_IMF(CEncoder::WriteCoderProperties(ISequentialOutStream *outStream))
 #define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
   if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
 
-Z7_COM7F_IMF(CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
-    const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress))
+STDMETHODIMP CEncoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 * /* inSize */, const UInt64 * /* outSize */, ICompressProgressInfo *progress)
 {
   CSeqInStreamWrap inWrap;
   CSeqOutStreamWrap outWrap;

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

@@ -1,7 +1,7 @@
 // Lzma2Encoder.h
 
-#ifndef ZIP7_INC_LZMA2_ENCODER_H
-#define ZIP7_INC_LZMA2_ENCODER_H
+#ifndef __LZMA2_ENCODER_H
+#define __LZMA2_ENCODER_H
 
 #include "../../../C/Lzma2Enc.h"
 
@@ -12,17 +12,29 @@
 namespace NCompress {
 namespace NLzma2 {
 
-Z7_CLASS_IMP_COM_4(
-  CEncoder
-  , ICompressCoder
-  , ICompressSetCoderProperties
-  , ICompressWriteCoderProperties
-  , ICompressSetCoderPropertiesOpt
-)
+class CEncoder:
+  public ICompressCoder,
+  public ICompressSetCoderProperties,
+  public ICompressWriteCoderProperties,
+  public ICompressSetCoderPropertiesOpt,
+  public CMyUnknownImp
+{
   CLzma2EncHandle _encoder;
 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();
-  ~CEncoder();
+  virtual ~CEncoder();
 };
 
 }}

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

@@ -6,7 +6,7 @@
 
 #include "Lzma2Decoder.h"
 
-#ifndef Z7_EXTRACT_ONLY
+#ifndef EXTRACT_ONLY
 #include "Lzma2Encoder.h"
 #endif
 

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

@@ -17,7 +17,6 @@ static HRESULT SResToHRESULT(SRes res)
     case SZ_ERROR_PARAM: return E_INVALIDARG;
     case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
     case SZ_ERROR_DATA: return S_FALSE;
-    default: break;
   }
   return E_FAIL;
 }
@@ -26,14 +25,14 @@ 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),
-    _lzmaStatus(LZMA_STATUS_NOT_SPECIFIED),
-    _inBuf(NULL)
+    _inBufSizeNew(1 << 20)
 {
   _inProcessed = 0;
   _inPos = _inLim = 0;
@@ -43,7 +42,7 @@ CDecoder::CDecoder():
   _alloc.numAlignBits = 7;
   _alloc.offset = 0;
   */
-  LzmaDec_CONSTRUCT(&_state)
+  LzmaDec_Construct(&_state);
 }
 
 CDecoder::~CDecoder()
@@ -52,10 +51,8 @@ CDecoder::~CDecoder()
   MyFree(_inBuf);
 }
 
-Z7_COM7F_IMF(CDecoder::SetInBufSize(UInt32 , UInt32 size))
-  { _inBufSizeNew = size; return S_OK; }
-Z7_COM7F_IMF(CDecoder::SetOutBufSize(UInt32 , UInt32 size))
-  { _outStep = size; return S_OK; }
+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()
 {
@@ -72,7 +69,7 @@ HRESULT CDecoder::CreateInputBuffer()
 }
 
 
-Z7_COM7F_IMF(CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size))
+STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
 {
   RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_AlignedAlloc))) // &_alloc.vt
   _propsWereSet = true;
@@ -93,7 +90,7 @@ void CDecoder::SetOutStreamSizeResume(const UInt64 *outSize)
 }
 
 
-Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
+STDMETHODIMP CDecoder::SetOutStreamSize(const UInt64 *outSize)
 {
   _inProcessed = 0;
   _inPos = _inLim = 0;
@@ -102,14 +99,14 @@ Z7_COM7F_IMF(CDecoder::SetOutStreamSize(const UInt64 *outSize))
 }
 
 
-Z7_COM7F_IMF(CDecoder::SetFinishMode(UInt32 finishMode))
+STDMETHODIMP CDecoder::SetFinishMode(UInt32 finishMode)
 {
   FinishStream = (finishMode != 0);
   return S_OK;
 }
 
 
-Z7_COM7F_IMF(CDecoder::GetInStreamProcessedSize(UInt64 *value))
+STDMETHODIMP CDecoder::GetInStreamProcessedSize(UInt64 *value)
 {
   *value = _inProcessed;
   return S_OK;
@@ -156,8 +153,8 @@ HRESULT CDecoder::CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *
 
     SizeT inProcessed = _inLim - _inPos;
     ELzmaStatus status;
-
-    const SRes res = LzmaDec_DecodeToDic(&_state, dicPos + size, _inBuf + _inPos, &inProcessed, finishMode, &status);
+    
+    SRes res = LzmaDec_DecodeToDic(&_state, dicPos + size, _inBuf + _inPos, &inProcessed, finishMode, &status);
 
     _lzmaStatus = status;
     _inPos += (UInt32)inProcessed;
@@ -166,30 +163,27 @@ HRESULT CDecoder::CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *
     _outProcessed += outProcessed;
 
     // we check for LZMA_STATUS_NEEDS_MORE_INPUT to allow RangeCoder initialization, if (_outSizeDefined && _outSize == 0)
-    const bool outFinished = (_outSizeDefined && _outProcessed >= _outSize);
+    bool outFinished = (_outSizeDefined && _outProcessed >= _outSize);
 
-    const bool needStop = (res != 0
+    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)
     {
-      const HRESULT res2 = WriteStream(outStream, _state.dic + wrPos, _state.dicPos - wrPos);
+      HRESULT res2 = WriteStream(outStream, _state.dic + wrPos, _state.dicPos - wrPos);
 
       if (_state.dicPos == _state.dicBufSize)
         _state.dicPos = 0;
       wrPos = _state.dicPos;
       
-      RINOK(res2)
+      RINOK(res2);
 
       if (needStop)
       {
         if (res != 0)
-        {
-          // return SResToHRESULT(res);
           return S_FALSE;
-        }
 
         if (status == LZMA_STATUS_FINISHED_WITH_MARK)
         {
@@ -210,14 +204,14 @@ HRESULT CDecoder::CodeSpec(ISequentialInStream *inStream, ISequentialOutStream *
     if (progress)
     {
       const UInt64 inSize = _inProcessed - startInProgress;
-      RINOK(progress->SetRatioInfo(&inSize, &_outProcessed))
+      RINOK(progress->SetRatioInfo(&inSize, &_outProcessed));
     }
   }
 }
 
 
-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 (!_inBuf)
     return E_INVALIDARG;
@@ -230,14 +224,13 @@ Z7_COM7F_IMF(CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
 }
 
 
-#ifndef Z7_NO_READ_FROM_CODER
+#ifndef NO_READ_FROM_CODER
+
+STDMETHODIMP CDecoder::SetInStream(ISequentialInStream *inStream) { _inStream = inStream; return S_OK; }
+STDMETHODIMP CDecoder::ReleaseInStream() { _inStream.Release(); return S_OK; }
 
-Z7_COM7F_IMF(CDecoder::SetInStream(ISequentialInStream *inStream))
-  { _inStream = inStream; return S_OK; }
-Z7_COM7F_IMF(CDecoder::ReleaseInStream())
-  { _inStream.Release(); return S_OK; }
 
-Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
+STDMETHODIMP CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   if (processedSize)
     *processedSize = 0;
@@ -268,7 +261,7 @@ Z7_COM7F_IMF(CDecoder::Read(void *data, UInt32 size, UInt32 *processedSize))
     SizeT outProcessed = size;
     ELzmaStatus status;
     
-    const SRes res = LzmaDec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
+    SRes res = LzmaDec_DecodeToBuf(&_state, (Byte *)data, &outProcessed,
         _inBuf + _inPos, &inProcessed, finishMode, &status);
     
     _lzmaStatus = status;
@@ -312,7 +305,7 @@ HRESULT CDecoder::CodeResume(ISequentialOutStream *outStream, const UInt64 *outS
 
 HRESULT CDecoder::ReadFromInputStream(void *data, UInt32 size, UInt32 *processedSize)
 {
-  RINOK(CreateInputBuffer())
+  RINOK(CreateInputBuffer());
   
   if (processedSize)
     *processedSize = 0;