react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/C/XzEnc.h

@@ -1,8 +1,8 @@
 /* XzEnc.h -- Xz Encode
-: Igor Pavlov : Public domain */
+2017-06-27 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_XZ_ENC_H
-#define ZIP7_INC_XZ_ENC_H
+#ifndef __XZ_ENC_H
+#define __XZ_ENC_H
 
 #include "Lzma2Enc.h"
 
@@ -11,8 +11,8 @@
 EXTERN_C_BEGIN
 
 
-#define XZ_PROPS_BLOCK_SIZE_AUTO   LZMA2_ENC_PROPS_BLOCK_SIZE_AUTO
-#define XZ_PROPS_BLOCK_SIZE_SOLID  LZMA2_ENC_PROPS_BLOCK_SIZE_SOLID
+#define XZ_PROPS__BLOCK_SIZE__AUTO   LZMA2_ENC_PROPS__BLOCK_SIZE__AUTO
+#define XZ_PROPS__BLOCK_SIZE__SOLID  LZMA2_ENC_PROPS__BLOCK_SIZE__SOLID
 
 
 typedef struct
@@ -31,7 +31,6 @@ typedef struct
   CLzma2EncProps lzma2Props;
   CXzFilterProps filterProps;
   unsigned checkId;
-  unsigned numThreadGroups; // 0 : no groups
   UInt64 blockSize;
   int numBlockThreads_Reduced;
   int numBlockThreads_Max;
@@ -42,22 +41,19 @@ typedef struct
 
 void XzProps_Init(CXzProps *p);
 
-typedef struct CXzEnc CXzEnc;
-typedef CXzEnc * CXzEncHandle;
-// Z7_DECLARE_HANDLE(CXzEncHandle)
+
+typedef void * CXzEncHandle;
 
 CXzEncHandle XzEnc_Create(ISzAllocPtr alloc, ISzAllocPtr allocBig);
 void XzEnc_Destroy(CXzEncHandle p);
 SRes XzEnc_SetProps(CXzEncHandle p, const CXzProps *props);
 void XzEnc_SetDataSize(CXzEncHandle p, UInt64 expectedDataSiize);
-SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream, ICompressProgressPtr progress);
-SRes XzEnc_Encode_Part(CXzEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
-                       ICompressProgressPtr progress,int isWriteHead,int isWriteFooter);
+SRes XzEnc_Encode(CXzEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream, ICompressProgress *progress);
 
-SRes Xz_Encode(ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
-    const CXzProps *props, ICompressProgressPtr progress);
+SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
+    const CXzProps *props, ICompressProgress *progress);
 
-SRes Xz_EncodeEmpty(ISeqOutStreamPtr outStream);
+SRes Xz_EncodeEmpty(ISeqOutStream *outStream);
 
 EXTERN_C_END
 

package/harmony/pushy/src/main/cpp/lzma/C/XzIn.c

@@ -1,44 +1,40 @@
 /* XzIn.c - Xz input
-: Igor Pavlov : Public domain */
+2018-07-04 : Igor Pavlov : Public domain */
 
 #include "Precomp.h"
 
 #include <string.h>
 
 #include "7zCrc.h"
-#include "Xz.h"
 #include "CpuArch.h"
+#include "Xz.h"
+
+/*
+#define XZ_FOOTER_SIG_CHECK(p) (memcmp((p), XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) == 0)
+*/
+#define XZ_FOOTER_SIG_CHECK(p) ((p)[0] == XZ_FOOTER_SIG_0 && (p)[1] == XZ_FOOTER_SIG_1)
 
-#define XZ_FOOTER_12B_ALIGNED16_SIG_CHECK(p) \
-    (GetUi16a((const Byte *)(const void *)(p) + 10) == \
-      (XZ_FOOTER_SIG_0 | (XZ_FOOTER_SIG_1 << 8)))
 
-SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStreamPtr inStream)
+SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream)
 {
-  UInt32 data32[XZ_STREAM_HEADER_SIZE / 4];
-  size_t processedSize = XZ_STREAM_HEADER_SIZE;
-  RINOK(SeqInStream_ReadMax(inStream, data32, &processedSize))
-  if (processedSize != XZ_STREAM_HEADER_SIZE
-      || memcmp(data32, XZ_SIG, XZ_SIG_SIZE) != 0)
+  Byte sig[XZ_STREAM_HEADER_SIZE];
+  RINOK(SeqInStream_Read2(inStream, sig, XZ_STREAM_HEADER_SIZE, SZ_ERROR_NO_ARCHIVE));
+  if (memcmp(sig, XZ_SIG, XZ_SIG_SIZE) != 0)
     return SZ_ERROR_NO_ARCHIVE;
-  return Xz_ParseHeader(p, (const Byte *)(const void *)data32);
+  return Xz_ParseHeader(p, sig);
 }
 
-#define READ_VARINT_AND_CHECK(buf, size, res) \
-{ const unsigned s = Xz_ReadVarInt(buf, size, res); \
-  if (s == 0) return SZ_ERROR_ARCHIVE; \
-  size -= s; \
-  buf += s; \
-}
+#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
+  { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
+  if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
 
-SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStreamPtr inStream, BoolInt *isIndex, UInt32 *headerSizeRes)
+SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, BoolInt *isIndex, UInt32 *headerSizeRes)
 {
-  MY_ALIGN(4)
   Byte header[XZ_BLOCK_HEADER_SIZE_MAX];
   unsigned headerSize;
   *headerSizeRes = 0;
-  RINOK(SeqInStream_ReadByte(inStream, &header[0]))
-  headerSize = header[0];
+  RINOK(SeqInStream_ReadByte(inStream, &header[0]));
+  headerSize = (unsigned)header[0];
   if (headerSize == 0)
   {
     *headerSizeRes = 1;
@@ -48,31 +44,20 @@ SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStreamPtr inStream, BoolInt *isIndex,
 
   *isIndex = False;
   headerSize = (headerSize << 2) + 4;
-  *headerSizeRes = (UInt32)headerSize;
-  {
-    size_t processedSize = headerSize - 1;
-    RINOK(SeqInStream_ReadMax(inStream, header + 1, &processedSize))
-    if (processedSize != headerSize - 1)
-      return SZ_ERROR_INPUT_EOF;
-  }
+  *headerSizeRes = headerSize;
+  RINOK(SeqInStream_Read(inStream, header + 1, headerSize - 1));
   return XzBlock_Parse(p, header);
 }
 
-
 #define ADD_SIZE_CHECK(size, val) \
-{ const UInt64 newSize = size + (val); \
-  if (newSize < size) return XZ_SIZE_OVERFLOW; \
-  size = newSize; \
-}
+  { UInt64 newSize = size + (val); if (newSize < size) return XZ_SIZE_OVERFLOW; size = newSize; }
 
 UInt64 Xz_GetUnpackSize(const CXzStream *p)
 {
   UInt64 size = 0;
   size_t i;
   for (i = 0; i < p->numBlocks; i++)
-  {
-    ADD_SIZE_CHECK(size, p->blocks[i].unpackSize)
-  }
+    ADD_SIZE_CHECK(size, p->blocks[i].unpackSize);
   return size;
 }
 
@@ -81,204 +66,171 @@ UInt64 Xz_GetPackSize(const CXzStream *p)
   UInt64 size = 0;
   size_t i;
   for (i = 0; i < p->numBlocks; i++)
-  {
-    ADD_SIZE_CHECK(size, (p->blocks[i].totalSize + 3) & ~(UInt64)3)
-  }
+    ADD_SIZE_CHECK(size, (p->blocks[i].totalSize + 3) & ~(UInt64)3);
   return size;
 }
 
+/*
+SRes XzBlock_ReadFooter(CXzBlock *p, CXzStreamFlags f, ISeqInStream *inStream)
+{
+  return SeqInStream_Read(inStream, p->check, XzFlags_GetCheckSize(f));
+}
+*/
 
-// input;
-//   CXzStream (p) is empty object.
-//   size != 0
-//   (size & 3) == 0
-//   (buf) is aligned for at least 4 bytes.
-// output:
-//   p->numBlocks is number of allocated items in p->blocks
-//   p->blocks[*] values must be ignored, if function returns error.
-static SRes Xz_ParseIndex(CXzStream *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
+static SRes Xz_ReadIndex2(CXzStream *p, const Byte *buf, size_t size, ISzAllocPtr alloc)
 {
-  size_t numBlocks;
+  size_t numBlocks, pos = 1;
+  UInt32 crc;
+
   if (size < 5 || buf[0] != 0)
     return SZ_ERROR_ARCHIVE;
+
   size -= 4;
-  {
-    const UInt32 crc = CrcCalc(buf, size);
-    if (crc != GetUi32a(buf + size))
-      return SZ_ERROR_ARCHIVE;
-  }
-  buf++;
-  size--;
+  crc = CrcCalc(buf, size);
+  if (crc != GetUi32(buf + size))
+    return SZ_ERROR_ARCHIVE;
+
   {
     UInt64 numBlocks64;
-    READ_VARINT_AND_CHECK(buf, size, &numBlocks64)
-    // (numBlocks64) is 63-bit value, so we can calculate (numBlocks64 * 2):
-    if (numBlocks64 * 2 > size)
-      return SZ_ERROR_ARCHIVE;
-    if (numBlocks64 >= ((size_t)1 << (sizeof(size_t) * 8 - 1)) / sizeof(CXzBlockSizes))
-      return SZ_ERROR_MEM; // SZ_ERROR_ARCHIVE
+    READ_VARINT_AND_CHECK(buf, pos, size, &numBlocks64);
     numBlocks = (size_t)numBlocks64;
+    if (numBlocks != numBlocks64 || numBlocks * 2 > size)
+      return SZ_ERROR_ARCHIVE;
   }
-  // Xz_Free(p, alloc); // it's optional, because (p) is empty already
-  if (numBlocks)
+  
+  Xz_Free(p, alloc);
+  if (numBlocks != 0)
   {
-    CXzBlockSizes *blocks = (CXzBlockSizes *)ISzAlloc_Alloc(alloc, sizeof(CXzBlockSizes) * numBlocks);
-    if (!blocks)
-      return SZ_ERROR_MEM;
-    p->blocks = blocks;
+    size_t i;
     p->numBlocks = numBlocks;
-    // the caller will call Xz_Free() in case of error
-    do
+    p->blocks = (CXzBlockSizes *)ISzAlloc_Alloc(alloc, sizeof(CXzBlockSizes) * numBlocks);
+    if (!p->blocks)
+      return SZ_ERROR_MEM;
+    for (i = 0; i < numBlocks; i++)
     {
-      READ_VARINT_AND_CHECK(buf, size, &blocks->totalSize)
-      READ_VARINT_AND_CHECK(buf, size, &blocks->unpackSize)
-      if (blocks->totalSize == 0)
+      CXzBlockSizes *block = &p->blocks[i];
+      READ_VARINT_AND_CHECK(buf, pos, size, &block->totalSize);
+      READ_VARINT_AND_CHECK(buf, pos, size, &block->unpackSize);
+      if (block->totalSize == 0)
         return SZ_ERROR_ARCHIVE;
-      blocks++;
     }
-    while (--numBlocks);
   }
-  if (size >= 4)
-    return SZ_ERROR_ARCHIVE;
-  while (size)
-    if (buf[--size])
+  while ((pos & 3) != 0)
+    if (buf[pos++] != 0)
       return SZ_ERROR_ARCHIVE;
-  return SZ_OK;
+  return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
 }
 
-
-/*
-static SRes Xz_ReadIndex(CXzStream *p, ILookInStreamPtr stream, UInt64 indexSize, ISzAllocPtr alloc)
+static SRes Xz_ReadIndex(CXzStream *p, ILookInStream *stream, UInt64 indexSize, ISzAllocPtr alloc)
 {
   SRes res;
   size_t size;
   Byte *buf;
-  if (indexSize >= ((size_t)1 << (sizeof(size_t) * 8 - 1)))
-    return SZ_ERROR_MEM; // SZ_ERROR_ARCHIVE
+  if (indexSize > ((UInt32)1 << 31))
+    return SZ_ERROR_UNSUPPORTED;
   size = (size_t)indexSize;
+  if (size != indexSize)
+    return SZ_ERROR_UNSUPPORTED;
   buf = (Byte *)ISzAlloc_Alloc(alloc, size);
   if (!buf)
     return SZ_ERROR_MEM;
   res = LookInStream_Read2(stream, buf, size, SZ_ERROR_UNSUPPORTED);
   if (res == SZ_OK)
-    res = Xz_ParseIndex(p, buf, size, alloc);
+    res = Xz_ReadIndex2(p, buf, size, alloc);
   ISzAlloc_Free(alloc, buf);
   return res;
 }
-*/
 
-static SRes LookInStream_SeekRead_ForArc(ILookInStreamPtr stream, UInt64 offset, void *buf, size_t size)
+static SRes LookInStream_SeekRead_ForArc(ILookInStream *stream, UInt64 offset, void *buf, size_t size)
 {
-  RINOK(LookInStream_SeekTo(stream, offset))
+  RINOK(LookInStream_SeekTo(stream, offset));
   return LookInStream_Read(stream, buf, size);
   /* return LookInStream_Read2(stream, buf, size, SZ_ERROR_NO_ARCHIVE); */
 }
 
-
-/*
-in:
-  (*startOffset) is position in (stream) where xz_stream must be finished.
-out:
-  if returns SZ_OK, then (*startOffset) is position in stream that shows start of xz_stream.
-*/
-static SRes Xz_ReadBackward(CXzStream *p, ILookInStreamPtr stream, Int64 *startOffset, ISzAllocPtr alloc)
+static SRes Xz_ReadBackward(CXzStream *p, ILookInStream *stream, Int64 *startOffset, ISzAllocPtr alloc)
 {
-  #define TEMP_BUF_SIZE  (1 << 10)
-  UInt32 buf32[TEMP_BUF_SIZE / 4];
-  UInt64 pos = (UInt64)*startOffset;
+  UInt64 indexSize;
+  Byte buf[XZ_STREAM_FOOTER_SIZE];
+  UInt64 pos = *startOffset;
 
-  if ((pos & 3) || pos < XZ_STREAM_FOOTER_SIZE)
+  if ((pos & 3) != 0 || pos < XZ_STREAM_FOOTER_SIZE)
     return SZ_ERROR_NO_ARCHIVE;
+
   pos -= XZ_STREAM_FOOTER_SIZE;
-  RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf32, XZ_STREAM_FOOTER_SIZE))
+  RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE));
   
-  if (!XZ_FOOTER_12B_ALIGNED16_SIG_CHECK(buf32))
+  if (!XZ_FOOTER_SIG_CHECK(buf + 10))
   {
+    UInt32 total = 0;
     pos += XZ_STREAM_FOOTER_SIZE;
+    
     for (;;)
     {
-      // pos != 0
-      // (pos & 3) == 0
-      size_t i = pos >= TEMP_BUF_SIZE ? TEMP_BUF_SIZE : (size_t)pos;
+      size_t i;
+      #define TEMP_BUF_SIZE (1 << 10)
+      Byte temp[TEMP_BUF_SIZE];
+      
+      i = (pos > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)pos;
       pos -= i;
-      RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf32, i))
-      i /= 4;
-      do
-        if (buf32[i - 1] != 0)
+      RINOK(LookInStream_SeekRead_ForArc(stream, pos, temp, i));
+      total += (UInt32)i;
+      for (; i != 0; i--)
+        if (temp[i - 1] != 0)
           break;
-      while (--i);
-
-      pos += i * 4;
-      #define XZ_STREAM_BACKWARD_READING_PAD_MAX (1 << 16)
-      // here we don't support rare case with big padding for xz stream.
-      // so we have padding limit for backward reading.
-      if ((UInt64)*startOffset - pos > XZ_STREAM_BACKWARD_READING_PAD_MAX)
-        return SZ_ERROR_NO_ARCHIVE;
-      if (i)
+      if (i != 0)
+      {
+        if ((i & 3) != 0)
+          return SZ_ERROR_NO_ARCHIVE;
+        pos += i;
         break;
+      }
+      if (pos < XZ_STREAM_FOOTER_SIZE || total > (1 << 16))
+        return SZ_ERROR_NO_ARCHIVE;
     }
-    // we try to open xz stream after skipping zero padding.
-    // ((UInt64)*startOffset == pos) is possible here!
+    
     if (pos < XZ_STREAM_FOOTER_SIZE)
       return SZ_ERROR_NO_ARCHIVE;
     pos -= XZ_STREAM_FOOTER_SIZE;
-    RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf32, XZ_STREAM_FOOTER_SIZE))
-    if (!XZ_FOOTER_12B_ALIGNED16_SIG_CHECK(buf32))
+    RINOK(LookInStream_SeekRead_ForArc(stream, pos, buf, XZ_STREAM_FOOTER_SIZE));
+    if (!XZ_FOOTER_SIG_CHECK(buf + 10))
       return SZ_ERROR_NO_ARCHIVE;
   }
   
-  p->flags = (CXzStreamFlags)GetBe16a(buf32 + 2);
+  p->flags = (CXzStreamFlags)GetBe16(buf + 8);
+
   if (!XzFlags_IsSupported(p->flags))
     return SZ_ERROR_UNSUPPORTED;
+
+  if (GetUi32(buf) != CrcCalc(buf + 4, 6))
+    return SZ_ERROR_ARCHIVE;
+
+  indexSize = ((UInt64)GetUi32(buf + 4) + 1) << 2;
+
+  if (pos < indexSize)
+    return SZ_ERROR_ARCHIVE;
+
+  pos -= indexSize;
+  RINOK(LookInStream_SeekTo(stream, pos));
+  RINOK(Xz_ReadIndex(p, stream, indexSize, alloc));
+
   {
-    /* to eliminate GCC 6.3 warning:
-       dereferencing type-punned pointer will break strict-aliasing rules */
-    const UInt32 *buf_ptr = buf32;
-    if (GetUi32a(buf_ptr) != CrcCalc(buf32 + 1, 6))
-      return SZ_ERROR_ARCHIVE;
-  }
-  {
-    const UInt64 indexSize = ((UInt64)GetUi32a(buf32 + 1) + 1) << 2;
-    if (pos < indexSize)
-      return SZ_ERROR_ARCHIVE;
-    pos -= indexSize;
-    // v25.00: relaxed indexSize check. We allow big index table.
-    // if (indexSize > ((UInt32)1 << 31))
-    if (indexSize >= ((size_t)1 << (sizeof(size_t) * 8 - 1)))
-      return SZ_ERROR_MEM; // SZ_ERROR_ARCHIVE
-    RINOK(LookInStream_SeekTo(stream, pos))
-    // RINOK(Xz_ReadIndex(p, stream, indexSize, alloc))
-    {
-      SRes res;
-      const size_t size = (size_t)indexSize;
-      // if (size != indexSize) return SZ_ERROR_UNSUPPORTED;
-      Byte *buf = (Byte *)ISzAlloc_Alloc(alloc, size);
-      if (!buf)
-        return SZ_ERROR_MEM;
-      res = LookInStream_Read2(stream, buf, size, SZ_ERROR_UNSUPPORTED);
-      if (res == SZ_OK)
-        res = Xz_ParseIndex(p, buf, size, alloc);
-      ISzAlloc_Free(alloc, buf);
-      RINOK(res)
-    }
-  }
-  {
-    UInt64 total = Xz_GetPackSize(p);
-    if (total == XZ_SIZE_OVERFLOW || total >= ((UInt64)1 << 63))
-      return SZ_ERROR_ARCHIVE;
-    total += XZ_STREAM_HEADER_SIZE;
-    if (pos < total)
+    UInt64 totalSize = Xz_GetPackSize(p);
+    if (totalSize == XZ_SIZE_OVERFLOW
+        || totalSize >= ((UInt64)1 << 63)
+        || pos < totalSize + XZ_STREAM_HEADER_SIZE)
       return SZ_ERROR_ARCHIVE;
-    pos -= total;
-    RINOK(LookInStream_SeekTo(stream, pos))
-    *startOffset = (Int64)pos;
+    pos -= (totalSize + XZ_STREAM_HEADER_SIZE);
+    RINOK(LookInStream_SeekTo(stream, pos));
+    *startOffset = pos;
   }
   {
     CXzStreamFlags headerFlags;
     CSecToRead secToRead;
     SecToRead_CreateVTable(&secToRead);
     secToRead.realStream = stream;
-    RINOK(Xz_ReadHeader(&headerFlags, &secToRead.vt))
+
+    RINOK(Xz_ReadHeader(&headerFlags, &secToRead.vt));
     return (p->flags == headerFlags) ? SZ_OK : SZ_ERROR_ARCHIVE;
   }
 }
@@ -288,7 +240,8 @@ static SRes Xz_ReadBackward(CXzStream *p, ILookInStreamPtr stream, Int64 *startO
 
 void Xzs_Construct(CXzs *p)
 {
-  Xzs_CONSTRUCT(p)
+  p->num = p->numAllocated = 0;
+  p->streams = 0;
 }
 
 void Xzs_Free(CXzs *p, ISzAllocPtr alloc)
@@ -298,7 +251,7 @@ void Xzs_Free(CXzs *p, ISzAllocPtr alloc)
     Xz_Free(&p->streams[i], alloc);
   ISzAlloc_Free(alloc, p->streams);
   p->num = p->numAllocated = 0;
-  p->streams = NULL;
+  p->streams = 0;
 }
 
 UInt64 Xzs_GetNumBlocks(const CXzs *p)
@@ -315,9 +268,7 @@ UInt64 Xzs_GetUnpackSize(const CXzs *p)
   UInt64 size = 0;
   size_t i;
   for (i = 0; i < p->num; i++)
-  {
-    ADD_SIZE_CHECK(size, Xz_GetUnpackSize(&p->streams[i]))
-  }
+    ADD_SIZE_CHECK(size, Xz_GetUnpackSize(&p->streams[i]));
   return size;
 }
 
@@ -327,59 +278,42 @@ UInt64 Xzs_GetPackSize(const CXzs *p)
   UInt64 size = 0;
   size_t i;
   for (i = 0; i < p->num; i++)
-  {
-    ADD_SIZE_CHECK(size, Xz_GetTotalSize(&p->streams[i]))
-  }
+    ADD_SIZE_CHECK(size, Xz_GetTotalSize(&p->streams[i]));
   return size;
 }
 */
 
-SRes Xzs_ReadBackward(CXzs *p, ILookInStreamPtr stream, Int64 *startOffset, ICompressProgressPtr progress, ISzAllocPtr alloc)
+SRes Xzs_ReadBackward(CXzs *p, ILookInStream *stream, Int64 *startOffset, ICompressProgress *progress, ISzAllocPtr alloc)
 {
   Int64 endOffset = 0;
-  // it's supposed that CXzs object is empty here.
-  // if CXzs object is not empty, it will add new streams to that non-empty object.
-  // Xzs_Free(p, alloc); // it's optional call to empty CXzs object.
-  RINOK(ILookInStream_Seek(stream, &endOffset, SZ_SEEK_END))
+  RINOK(ILookInStream_Seek(stream, &endOffset, SZ_SEEK_END));
   *startOffset = endOffset;
   for (;;)
   {
     CXzStream st;
     SRes res;
-    Xz_CONSTRUCT(&st)
+    Xz_Construct(&st);
     res = Xz_ReadBackward(&st, stream, startOffset, alloc);
-    // if (res == SZ_OK), then (*startOffset) is start offset of new stream if
-    // if (res != SZ_OK), then (*startOffset) is unchend or it's expected start offset of stream with error
-    st.startOffset = (UInt64)*startOffset;
-    // we must store (st) object to array, or we must free (st) local object.
-    if (res != SZ_OK)
-    {
-      Xz_Free(&st, alloc);
-      return res;
-    }
+    st.startOffset = *startOffset;
+    RINOK(res);
     if (p->num == p->numAllocated)
     {
-      const size_t newNum = p->num + p->num / 4 + 1;
-      void *data = ISzAlloc_Alloc(alloc, newNum * sizeof(CXzStream));
+      size_t newNum = p->num + p->num / 4 + 1;
+      Byte *data = (Byte *)ISzAlloc_Alloc(alloc, newNum * sizeof(CXzStream));
       if (!data)
-      {
-        Xz_Free(&st, alloc);
         return SZ_ERROR_MEM;
-      }
       p->numAllocated = newNum;
       if (p->num != 0)
         memcpy(data, p->streams, p->num * sizeof(CXzStream));
       ISzAlloc_Free(alloc, p->streams);
       p->streams = (CXzStream *)data;
     }
-    // we use direct copying of raw data from local variable (st) to object in array.
-    // so we don't need to call Xz_Free(&st, alloc) after copying and after p->num++
     p->streams[p->num++] = st;
     if (*startOffset == 0)
-      return SZ_OK;
-    // seek operation is optional:
-    // RINOK(LookInStream_SeekTo(stream, (UInt64)*startOffset))
-    if (progress && ICompressProgress_Progress(progress, (UInt64)(endOffset - *startOffset), (UInt64)(Int64)-1) != SZ_OK)
+      break;
+    RINOK(LookInStream_SeekTo(stream, *startOffset));
+    if (progress && ICompressProgress_Progress(progress, endOffset - *startOffset, (UInt64)(Int64)-1) != SZ_OK)
       return SZ_ERROR_PROGRESS;
   }
+  return SZ_OK;
 }

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

@@ -5,14 +5,14 @@ OBJS = \
   $(WIN_OBJS) \
   $(WIN_CTRL_OBJS) \
   $(7ZIP_COMMON_OBJS) \
+  $(AR_OBJS) \
+  $(AR_COMMON_OBJS) \
   $(UI_COMMON_OBJS) \
   $(AGENT_OBJS) \
   $(CONSOLE_OBJS) \
   $(EXPLORER_OBJS) \
   $(FM_OBJS) \
   $(GUI_OBJS) \
-  $(AR_COMMON_OBJS) \
-  $(AR_OBJS) \
   $(7Z_OBJS) \
   $(CAB_OBJS) \
   $(CHM_OBJS) \
@@ -124,7 +124,7 @@ $(WIM_OBJS): ../../Archive/Wim/$(*B).cpp
 
 !IFDEF ZIP_OBJS
 $(ZIP_OBJS): ../../Archive/Zip/$(*B).cpp
-	$(COMPL) $(ZIP_FLAGS)
+	$(COMPL)
 !ENDIF
 
 !IFDEF COMPRESS_OBJS
@@ -149,7 +149,7 @@ $(AGENT_OBJS): ../../UI/Agent/$(*B).cpp
 
 !IFDEF CONSOLE_OBJS
 $(CONSOLE_OBJS): ../../UI/Console/$(*B).cpp
-	$(COMPL) $(CONSOLE_VARIANT_FLAGS)
+	$(COMPL)
 !ENDIF
 
 !IFDEF EXPLORER_OBJS
@@ -191,7 +191,7 @@ $(C_OBJS): ../../../../C/$(*B).c
 {../../UI/Agent}.cpp{$O}.obj::
 	$(COMPLB)
 {../../UI/Console}.cpp{$O}.obj::
-	$(COMPLB) $(CONSOLE_VARIANT_FLAGS)
+	$(COMPLB)
 {../../UI/Explorer}.cpp{$O}.obj::
 	$(COMPLB)
 {../../UI/FileManager}.cpp{$O}.obj::
@@ -226,7 +226,7 @@ $(C_OBJS): ../../../../C/$(*B).c
 {../../Archive/Wim}.cpp{$O}.obj::
 	$(COMPLB)
 {../../Archive/Zip}.cpp{$O}.obj::
-	$(COMPLB) $(ZIP_FLAGS)
+	$(COMPLB)
 
 {../../Compress}.cpp{$O}.obj::
 	$(COMPLB_O2)

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Aes.mak

@@ -1,10 +1,7 @@
 C_OBJS = $(C_OBJS) \
   $O\Aes.obj
 
-!IF defined(USE_C_AES) || "$(PLATFORM)" == "arm" || "$(PLATFORM)" == "arm64"
-C_OBJS = $(C_OBJS) \
-  $O\AesOpt.obj
-!ELSEIF "$(PLATFORM)" != "ia64" && "$(PLATFORM)" != "mips" && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
+!IF "$(PLATFORM)" != "ia64" && "$(PLATFORM)" != "mips" && "$(PLATFORM)" != "arm" && "$(PLATFORM)" != "arm64"
 ASM_OBJS = $(ASM_OBJS) \
   $O\AesOpt.obj
 !ENDIF