Updated LZMA SDK to 9.38 beta.

The webpage says "If you use XZ code from LZMA SDK, it's recommended
to upgrade to new XZ code from 7-Zip 9.38 beta. That new code fixes
some bugs." and we do use the XZ code.

The code is identical to the stock LZMA SDK with the following changes:
  deleted bin/
  added C/Util/Lzma/Android.mk
  added MODULE_LICENSE_PUBLIC_DOMAIN
  added NOTICE
  added xz-embedded/

Change-Id: Ibc5d353748420f7b3ae2877d625d7ddb788bdc6e

103 files changed, 3895 insertions, 2184 deletions

diff --git a/C/7z.h b/C/7z.h
index b7edd3b..dc25f53 100755..100644
--- a/C/7z.h
+++ b/C/7z.h
@@ -1,89 +1,70 @@
 /* 7z.h -- 7z interface

-2010-03-11 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __7Z_H

 #define __7Z_H

 

-#include "7zBuf.h"

+#include "7zTypes.h"

 

 EXTERN_C_BEGIN

 

 #define k7zStartHeaderSize 0x20

 #define k7zSignatureSize 6

+

 extern Byte k7zSignature[k7zSignatureSize];

-#define k7zMajorVersion 0

 

-enum EIdEnum

+typedef struct

 {

-  k7zIdEnd,

-  k7zIdHeader,

-  k7zIdArchiveProperties,

-  k7zIdAdditionalStreamsInfo,

-  k7zIdMainStreamsInfo,

-  k7zIdFilesInfo,

-  k7zIdPackInfo,

-  k7zIdUnpackInfo,

-  k7zIdSubStreamsInfo,

-  k7zIdSize,

-  k7zIdCRC,

-  k7zIdFolder,

-  k7zIdCodersUnpackSize,

-  k7zIdNumUnpackStream,

-  k7zIdEmptyStream,

-  k7zIdEmptyFile,

-  k7zIdAnti,

-  k7zIdName,

-  k7zIdCTime,

-  k7zIdATime,

-  k7zIdMTime,

-  k7zIdWinAttributes,

-  k7zIdComment,

-  k7zIdEncodedHeader,

-  k7zIdStartPos,

-  k7zIdDummy

-};

+  const Byte *Data;

+  size_t Size;

+} CSzData;

+

+/* CSzCoderInfo & CSzFolder support only default methods */

 

 typedef struct

 {

-  UInt32 NumInStreams;

-  UInt32 NumOutStreams;

-  UInt64 MethodID;

-  CBuf Props;

+  size_t PropsOffset;

+  UInt32 MethodID;

+  Byte NumInStreams;

+  Byte NumOutStreams;

+  Byte PropsSize;

 } CSzCoderInfo;

 

-void SzCoderInfo_Init(CSzCoderInfo *p);

-void SzCoderInfo_Free(CSzCoderInfo *p, ISzAlloc *alloc);

-

 typedef struct

 {

   UInt32 InIndex;

   UInt32 OutIndex;

 } CSzBindPair;

 

+#define SZ_NUM_CODERS_IN_FOLDER_MAX 4

+#define SZ_NUM_BINDS_IN_FOLDER_MAX 3

+#define SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX 4

+#define SZ_NUM_CODERS_OUT_STREAMS_IN_FOLDER_MAX 4

+

 typedef struct

 {

-  CSzCoderInfo *Coders;

-  CSzBindPair *BindPairs;

-  UInt32 *PackStreams;

-  UInt64 *UnpackSizes;

   UInt32 NumCoders;

   UInt32 NumBindPairs;

   UInt32 NumPackStreams;

-  int UnpackCRCDefined;

-  UInt32 UnpackCRC;

-

-  UInt32 NumUnpackStreams;

+  UInt32 MainOutStream;

+  UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];

+  CSzBindPair BindPairs[SZ_NUM_BINDS_IN_FOLDER_MAX];

+  CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX];

+  UInt64 CodersUnpackSizes[SZ_NUM_CODERS_OUT_STREAMS_IN_FOLDER_MAX];

 } CSzFolder;

 

-void SzFolder_Init(CSzFolder *p);

-UInt64 SzFolder_GetUnpackSize(CSzFolder *p);

-int SzFolder_FindBindPairForInStream(CSzFolder *p, UInt32 inStreamIndex);

-UInt32 SzFolder_GetNumOutStreams(CSzFolder *p);

-UInt64 SzFolder_GetUnpackSize(CSzFolder *p);

+/*

+typedef struct

+{

+  size_t CodersDataOffset;

+  size_t UnpackSizeDataOffset;

+  // UInt32 StartCoderUnpackSizesIndex;

+  UInt32 StartPackStreamIndex;

+  // UInt32 IndexOfMainOutStream;

+} CSzFolder2;

+*/

 

-SRes SzFolder_Decode(const CSzFolder *folder, const UInt64 *packSizes,

-    ILookInStream *stream, UInt64 startPos,

-    Byte *outBuffer, size_t outSize, ISzAlloc *allocMain);

+SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd, CSzData *sdSizes);

 

 typedef struct

 {

@@ -93,35 +74,46 @@ typedef struct
 

 typedef struct

 {

-  CNtfsFileTime MTime;

-  UInt64 Size;

-  UInt32 Crc;

-  UInt32 Attrib;

-  Byte HasStream;

-  Byte IsDir;

-  Byte IsAnti;

-  Byte CrcDefined;

-  Byte MTimeDefined;

-  Byte AttribDefined;

-} CSzFileItem;

-

-void SzFile_Init(CSzFileItem *p);

+  Byte *Defs; /* MSB 0 bit numbering */

+  UInt32 *Vals;

+} CSzBitUi32s;

+

+typedef struct

+{

+  Byte *Defs; /* MSB 0 bit numbering */

+  // UInt64 *Vals;

+  CNtfsFileTime *Vals;

+} CSzBitUi64s;

+

+#define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)

+

+#define SzBitWithVals_Check(p, i) ((p)->Defs && ((p)->Defs[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)

 

 typedef struct

 {

-  UInt64 *PackSizes;

-  Byte *PackCRCsDefined;

-  UInt32 *PackCRCs;

-  CSzFolder *Folders;

-  CSzFileItem *Files;

   UInt32 NumPackStreams;

   UInt32 NumFolders;

-  UInt32 NumFiles;

+

+  UInt64 *PackPositions; // NumPackStreams + 1

+  CSzBitUi32s FolderCRCs;

+

+  size_t *FoCodersOffsets;

+  size_t *FoSizesOffsets;

+  // UInt32 StartCoderUnpackSizesIndex;

+  UInt32 *FoStartPackStreamIndex;

+

+  // CSzFolder2 *Folders;  // +1 item for sum values

+  Byte *CodersData;

+  Byte *UnpackSizesData;

+  size_t UnpackSizesDataSize;

+  // UInt64 *CoderUnpackSizes;

 } CSzAr;

 

-void SzAr_Init(CSzAr *p);

-void SzAr_Free(CSzAr *p, ISzAlloc *alloc);

 

+SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,

+    ILookInStream *stream, UInt64 startPos,

+    Byte *outBuffer, size_t outSize,

+    ISzAlloc *allocMain);

 

 /*

   SzExtract extracts file from archive

@@ -146,19 +138,34 @@ void SzAr_Free(CSzAr *p, ISzAlloc *alloc);
 typedef struct

 {

   CSzAr db;

-  

+

   UInt64 startPosAfterHeader;

   UInt64 dataPos;

+  

+  UInt32 NumFiles;

+

+  UInt64 *UnpackPositions;

+  // Byte *IsEmptyFiles;

+  Byte *IsDirs;

+  CSzBitUi32s CRCs;

 

-  UInt32 *FolderStartPackStreamIndex;

-  UInt64 *PackStreamStartPositions;

-  UInt32 *FolderStartFileIndex;

+  CSzBitUi32s Attribs;

+  // CSzBitUi32s Parents;

+  CSzBitUi64s MTime;

+  CSzBitUi64s CTime;

+

+  // UInt32 *FolderStartPackStreamIndex;

+  UInt32 *FolderStartFileIndex; // + 1

   UInt32 *FileIndexToFolderIndexMap;

 

   size_t *FileNameOffsets; /* in 2-byte steps */

-  CBuf FileNames;  /* UTF-16-LE */

+  Byte *FileNames;  /* UTF-16-LE */

 } CSzArEx;

 

+#define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i))

+

+#define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i])

+

 void SzArEx_Init(CSzArEx *p);

 void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc);

 UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);

@@ -172,6 +179,11 @@ if dest != NULL, the return value specifies the number of 16-bit characters that
 

 size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest);

 

+/*

+size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);

+UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest);

+*/

+

 SRes SzArEx_Extract(

     const CSzArEx *db,

     ILookInStream *inStream,

@@ -196,7 +208,8 @@ SZ_ERROR_INPUT_EOF
 SZ_ERROR_FAIL

 */

 

-SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp);

+SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,

+    ISzAlloc *allocMain, ISzAlloc *allocTemp);

 

 EXTERN_C_END

 

diff --git a/C/7zAlloc.c b/C/7zAlloc.c
index 8874496..698071c 100755..100644
--- a/C/7zAlloc.c
+++ b/C/7zAlloc.c
@@ -1,6 +1,8 @@
 /* 7zAlloc.c -- Allocation functions

 2010-10-29 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include "7zAlloc.h"

 

 /* #define _SZ_ALLOC_DEBUG */

diff --git a/C/7zAlloc.h b/C/7zAlloc.h
index 860f116..860f116 100755..100644
--- a/C/7zAlloc.h
+++ b/C/7zAlloc.h
diff --git a/C/7zArcIn.c b/C/7zArcIn.c
new file mode 100644
index 0000000..5fd4f6b
--- /dev/null
+++ b/C/7zArcIn.c
@@ -0,0 +1,1839 @@
+/* 7zArcIn.c -- 7z Input functions

+2014-06-16 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

+

+#include <string.h>

+

+#include "7z.h"

+#include "7zBuf.h"

+#include "7zCrc.h"

+#include "CpuArch.h"

+

+#define MY_ALLOC(T, p, size, alloc) { if ((size) == 0) p = 0; else \

+  if ((p = (T *)IAlloc_Alloc(alloc, (size) * sizeof(T))) == 0) return SZ_ERROR_MEM; }

+

+#define k7zMajorVersion 0

+

+enum EIdEnum

+{

+  k7zIdEnd,

+  k7zIdHeader,

+  k7zIdArchiveProperties,

+  k7zIdAdditionalStreamsInfo,

+  k7zIdMainStreamsInfo,

+  k7zIdFilesInfo,

+  k7zIdPackInfo,

+  k7zIdUnpackInfo,

+  k7zIdSubStreamsInfo,

+  k7zIdSize,

+  k7zIdCRC,

+  k7zIdFolder,

+  k7zIdCodersUnpackSize,

+  k7zIdNumUnpackStream,

+  k7zIdEmptyStream,

+  k7zIdEmptyFile,

+  k7zIdAnti,

+  k7zIdName,

+  k7zIdCTime,

+  k7zIdATime,

+  k7zIdMTime,

+  k7zIdWinAttrib,

+  k7zIdComment,

+  k7zIdEncodedHeader,

+  k7zIdStartPos,

+  k7zIdDummy

+  // k7zNtSecure,

+  // k7zParent,

+  // k7zIsReal

+};

+

+Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};

+

+#define NUM_FOLDER_CODERS_MAX 32

+#define NUM_CODER_STREAMS_MAX 32

+

+/*

+static int SzFolder_FindBindPairForInStream(const CSzFolder *p, UInt32 inStreamIndex)

+{

+  UInt32 i;

+  for (i = 0; i < p->NumBindPairs; i++)

+    if (p->BindPairs[i].InIndex == inStreamIndex)

+      return i;

+  return -1;

+}

+*/

+

+#define SzBitUi32s_Init(p) { (p)->Defs = 0; (p)->Vals = 0; }

+

+static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAlloc *alloc)

+{

+  MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc);

+  MY_ALLOC(UInt32, p->Vals, num, alloc);

+  return SZ_OK;

+}

+

+void SzBitUi32s_Free(CSzBitUi32s *p, ISzAlloc *alloc)

+{

+  IAlloc_Free(alloc, p->Defs); p->Defs = 0;

+  IAlloc_Free(alloc, p->Vals); p->Vals = 0;

+}

+

+#define SzBitUi64s_Init(p) { (p)->Defs = 0; (p)->Vals = 0; }

+

+void SzBitUi64s_Free(CSzBitUi64s *p, ISzAlloc *alloc)

+{

+  IAlloc_Free(alloc, p->Defs); p->Defs = 0;

+  IAlloc_Free(alloc, p->Vals); p->Vals = 0;

+}

+

+static void SzAr_Init(CSzAr *p)

+{

+  p->NumPackStreams = 0;

+  p->NumFolders = 0;

+  p->PackPositions = 0;

+  SzBitUi32s_Init(&p->FolderCRCs);

+  // p->Folders = 0;

+  p->FoCodersOffsets = 0;

+  p->FoSizesOffsets = 0;

+  p->FoStartPackStreamIndex = 0;

+

+  p->CodersData = 0;

+  // p->CoderUnpackSizes = 0;

+  p->UnpackSizesData = 0;

+}

+

+static void SzAr_Free(CSzAr *p, ISzAlloc *alloc)

+{

+  IAlloc_Free(alloc, p->UnpackSizesData);

+  IAlloc_Free(alloc, p->CodersData);

+  // IAlloc_Free(alloc, p->CoderUnpackSizes);

+

+  IAlloc_Free(alloc, p->PackPositions);

+ 

+  // IAlloc_Free(alloc, p->Folders);

+  IAlloc_Free(alloc, p->FoCodersOffsets);

+  IAlloc_Free(alloc, p->FoSizesOffsets);

+  IAlloc_Free(alloc, p->FoStartPackStreamIndex);

+  

+  SzBitUi32s_Free(&p->FolderCRCs, alloc);

+

+  SzAr_Init(p);

+}

+

+

+void SzArEx_Init(CSzArEx *p)

+{

+  SzAr_Init(&p->db);

+  p->NumFiles = 0;

+  p->dataPos = 0;

+  // p->Files = 0;

+  p->UnpackPositions = 0;

+  // p->IsEmptyFiles = 0;

+  p->IsDirs = 0;

+  // p->FolderStartPackStreamIndex = 0;

+  // p->PackStreamStartPositions = 0;

+  p->FolderStartFileIndex = 0;

+  p->FileIndexToFolderIndexMap = 0;

+  p->FileNameOffsets = 0;

+  p->FileNames = 0;

+  SzBitUi32s_Init(&p->CRCs);

+  SzBitUi32s_Init(&p->Attribs);

+  // SzBitUi32s_Init(&p->Parents);

+  SzBitUi64s_Init(&p->MTime);

+  SzBitUi64s_Init(&p->CTime);

+}

+

+void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc)

+{

+  // IAlloc_Free(alloc, p->FolderStartPackStreamIndex);

+  // IAlloc_Free(alloc, p->PackStreamStartPositions);

+  IAlloc_Free(alloc, p->FolderStartFileIndex);

+  IAlloc_Free(alloc, p->FileIndexToFolderIndexMap);

+

+  IAlloc_Free(alloc, p->FileNameOffsets);

+  IAlloc_Free(alloc, p->FileNames);

+

+  SzBitUi64s_Free(&p->CTime, alloc);

+  SzBitUi64s_Free(&p->MTime, alloc);

+  SzBitUi32s_Free(&p->CRCs, alloc);

+  // SzBitUi32s_Free(&p->Parents, alloc);

+  SzBitUi32s_Free(&p->Attribs, alloc);

+  IAlloc_Free(alloc, p->IsDirs);

+  // IAlloc_Free(alloc, p->IsEmptyFiles);

+  IAlloc_Free(alloc, p->UnpackPositions);

+  // IAlloc_Free(alloc, p->Files);

+

+  SzAr_Free(&p->db, alloc);

+  SzArEx_Init(p);

+}

+

+static int TestSignatureCandidate(Byte *testBytes)

+{

+  size_t i;

+  for (i = 0; i < k7zSignatureSize; i++)

+    if (testBytes[i] != k7zSignature[i])

+      return 0;

+  return 1;

+}

+

+#define SzData_Clear(p) { (p)->Data = 0; (p)->Size = 0; }

+

+static SRes SzReadByte(CSzData *sd, Byte *b)

+{

+  if (sd->Size == 0)

+    return SZ_ERROR_ARCHIVE;

+  sd->Size--;

+  *b = *sd->Data++;

+  return SZ_OK;

+}

+

+#define SZ_READ_BYTE_SD(_sd_, dest) if ((_sd_)->Size == 0) return SZ_ERROR_ARCHIVE; (_sd_)->Size--; dest = *(_sd_)->Data++;

+#define SZ_READ_BYTE(dest) SZ_READ_BYTE_SD(sd, dest)

+#define SZ_READ_BYTE_2(dest) if (sd.Size == 0) return SZ_ERROR_ARCHIVE; sd.Size--; dest = *sd.Data++;

+

+#define SKIP_DATA(sd, size) { sd->Size -= (size_t)(size); sd->Data += (size_t)(size); }

+#define SKIP_DATA2(sd, size) { sd.Size -= (size_t)(size); sd.Data += (size_t)(size); }

+

+#define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \

+   dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4);

+

+static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)

+{

+  Byte firstByte, mask;

+  unsigned i;

+  UInt32 v;

+

+  SZ_READ_BYTE(firstByte);

+  if ((firstByte & 0x80) == 0)

+  {

+    *value = firstByte;

+    return SZ_OK;

+  }

+  SZ_READ_BYTE(v);

+  if ((firstByte & 0x40) == 0)

+  {

+    *value = (((UInt32)firstByte & 0x3F) << 8) | v;

+    return SZ_OK;

+  }

+  SZ_READ_BYTE(mask);

+  *value = v | ((UInt32)mask << 8);

+  mask = 0x20;

+  for (i = 2; i < 8; i++)

+  {

+    Byte b;

+    if ((firstByte & mask) == 0)

+    {

+      UInt64 highPart = firstByte & (mask - 1);

+      *value |= (highPart << (8 * i));

+      return SZ_OK;

+    }

+    SZ_READ_BYTE(b);

+    *value |= ((UInt64)b << (8 * i));

+    mask >>= 1;

+  }

+  return SZ_OK;

+}

+

+/*

+static MY_NO_INLINE const Byte *SzReadNumbers(const Byte *data, const Byte *dataLim, UInt64 *values, UInt32 num)

+{

+  for (; num != 0; num--)

+  {

+    Byte firstByte;

+    Byte mask;

+

+    unsigned i;

+    UInt32 v;

+    UInt64 value;

+   

+    if (data == dataLim)

+      return NULL;

+    firstByte = *data++;

+

+    if ((firstByte & 0x80) == 0)

+    {

+      *values++ = firstByte;

+      continue;

+    }

+    if (data == dataLim)

+      return NULL;

+    v = *data++;

+    if ((firstByte & 0x40) == 0)

+    {

+      *values++ = (((UInt32)firstByte & 0x3F) << 8) | v;

+      continue;

+    }

+    if (data == dataLim)

+      return NULL;

+    value = v | ((UInt32)*data++ << 8);

+    mask = 0x20;

+    for (i = 2; i < 8; i++)

+    {

+      if ((firstByte & mask) == 0)

+      {

+        UInt64 highPart = firstByte & (mask - 1);

+        value |= (highPart << (8 * i));

+        break;

+      }

+      if (data == dataLim)

+        return NULL;

+      value |= ((UInt64)*data++ << (8 * i));

+      mask >>= 1;

+    }

+    *values++ = value;

+  }

+  return data;

+}

+*/

+

+static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)

+{

+  Byte firstByte;

+  UInt64 value64;

+  if (sd->Size == 0)

+    return SZ_ERROR_ARCHIVE;

+  firstByte = *sd->Data;

+  if ((firstByte & 0x80) == 0)

+  {

+    *value = firstByte;

+    sd->Data++;

+    sd->Size--;

+    return SZ_OK;

+  }

+  RINOK(ReadNumber(sd, &value64));

+  if (value64 >= (UInt32)0x80000000 - 1)

+    return SZ_ERROR_UNSUPPORTED;

+  if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4)))

+    return SZ_ERROR_UNSUPPORTED;

+  *value = (UInt32)value64;

+  return SZ_OK;

+}

+

+#define ReadID(sd, value) ReadNumber(sd, value)

+

+static SRes SkipData(CSzData *sd)

+{

+  UInt64 size;

+  RINOK(ReadNumber(sd, &size));

+  if (size > sd->Size)

+    return SZ_ERROR_ARCHIVE;

+  SKIP_DATA(sd, size);

+  return SZ_OK;

+}

+

+static SRes WaitId(CSzData *sd, UInt64 id)

+{

+  for (;;)

+  {

+    UInt64 type;

+    RINOK(ReadID(sd, &type));

+    if (type == id)

+      return SZ_OK;

+    if (type == k7zIdEnd)

+      return SZ_ERROR_ARCHIVE;

+    RINOK(SkipData(sd));

+  }

+}

+

+static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)

+{

+  UInt32 numBytes = (numItems + 7) >> 3;

+  if (numBytes > sd->Size)

+    return SZ_ERROR_ARCHIVE;

+  *v = sd->Data;

+  SKIP_DATA(sd, numBytes);

+  return SZ_OK;

+}

+

+static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)

+{

+  Byte b = 0;

+  unsigned m = 0;

+  UInt32 sum = 0;

+  for (; numItems != 0; numItems--)

+  {

+    if (m == 0)

+    {

+      b = *bits++;

+      m = 8;

+    }

+    m--;

+    sum += ((b >> m) & 1);

+  }

+  return sum ;

+}

+

+static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAlloc *alloc)

+{

+  Byte allAreDefined;

+  UInt32 i;

+  Byte *v2;

+  UInt32 numBytes = (numItems + 7) >> 3;

+  RINOK(SzReadByte(sd, &allAreDefined));

+  if (allAreDefined == 0)

+  {

+    if (numBytes > sd->Size)

+      return SZ_ERROR_ARCHIVE;

+    MY_ALLOC(Byte, *v, numBytes, alloc);

+    memcpy(*v, sd->Data, numBytes);

+    SKIP_DATA(sd, numBytes);

+    return SZ_OK;

+  }

+  MY_ALLOC(Byte, *v, numBytes, alloc);

+  v2 = *v;

+  for (i = 0; i < numBytes; i++)

+    v2[i] = 0xFF;

+  {

+    unsigned numBits = (unsigned)numItems & 7;

+    if (numBits != 0)

+      v2[numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));

+  }

+  return SZ_OK;

+}

+

+static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)

+{

+  UInt32 i;

+  CSzData sd;

+  UInt32 *vals;

+  const Byte *defs;

+  MY_ALLOC(UInt32, crcs->Vals, numItems, alloc);

+  sd = *sd2;

+  defs = crcs->Defs;

+  vals = crcs->Vals;

+  for (i = 0; i < numItems; i++)

+    if (SzBitArray_Check(defs, i))

+    {

+      SZ_READ_32(vals[i]);

+    }

+    else

+      vals[i] = 0;

+  *sd2 = sd;

+  return SZ_OK;

+}

+

+static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)

+{

+  SzBitUi32s_Free(crcs, alloc);

+  RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc));

+  return ReadUi32s(sd, numItems, crcs, alloc);

+}

+

+static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)

+{

+  Byte allAreDefined;

+  UInt32 numDefined = numItems;

+  RINOK(SzReadByte(sd, &allAreDefined));

+  if (!allAreDefined)

+  {

+    size_t numBytes = (numItems + 7) >> 3;

+    if (numBytes > sd->Size)

+      return SZ_ERROR_ARCHIVE;

+    numDefined = CountDefinedBits(sd->Data, numItems);

+    SKIP_DATA(sd, numBytes);

+  }

+  if (numDefined > (sd->Size >> 2))

+    return SZ_ERROR_ARCHIVE;

+  SKIP_DATA(sd, (size_t)numDefined * 4);

+  return SZ_OK;

+}

+

+static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAlloc *alloc)

+{

+  RINOK(SzReadNumber32(sd, &p->NumPackStreams));

+

+  RINOK(WaitId(sd, k7zIdSize));

+  MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc);

+  {

+    UInt64 sum = 0;

+    UInt32 i;

+    UInt32 numPackStreams = p->NumPackStreams;

+    for (i = 0; i < numPackStreams; i++)

+    {

+      UInt64 packSize;

+      p->PackPositions[i] = sum;

+      RINOK(ReadNumber(sd, &packSize));

+      sum += packSize;

+      if (sum < packSize)

+        return SZ_ERROR_ARCHIVE;

+    }

+    p->PackPositions[i] = sum;

+  }

+

+  for (;;)

+  {

+    UInt64 type;

+    RINOK(ReadID(sd, &type));

+    if (type == k7zIdEnd)

+      return SZ_OK;

+    if (type == k7zIdCRC)

+    {

+      /* CRC of packed streams is unused now */

+      RINOK(SkipBitUi32s(sd, p->NumPackStreams));

+      continue;

+    }

+    RINOK(SkipData(sd));

+  }

+}

+

+/*

+static SRes SzReadSwitch(CSzData *sd)

+{

+  Byte external;

+  RINOK(SzReadByte(sd, &external));

+  return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;

+}

+*/

+

+#define SZ_NUM_IN_STREAMS_IN_FOLDER_MAX 16

+

+SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd, CSzData *sdSizes)

+{

+  UInt32 numCoders, numBindPairs, numPackStreams, i;

+  UInt32 numInStreams = 0, numOutStreams = 0;

+  const Byte *dataStart = sd->Data;

+  Byte inStreamUsed[SZ_NUM_IN_STREAMS_IN_FOLDER_MAX];

+  

+  RINOK(SzReadNumber32(sd, &numCoders));

+  if (numCoders > SZ_NUM_CODERS_IN_FOLDER_MAX)

+    return SZ_ERROR_UNSUPPORTED;

+  f->NumCoders = numCoders;

+  

+  for (i = 0; i < numCoders; i++)

+  {

+    Byte mainByte;

+    CSzCoderInfo *coder = f->Coders + i;

+    unsigned idSize, j;

+    UInt64 id;

+    RINOK(SzReadByte(sd, &mainByte));

+    if ((mainByte & 0xC0) != 0)

+      return SZ_ERROR_UNSUPPORTED;

+    idSize = (unsigned)(mainByte & 0xF);

+    if (idSize > sizeof(id))

+      return SZ_ERROR_UNSUPPORTED;

+    if (idSize > sd->Size)

+      return SZ_ERROR_ARCHIVE;

+    id = 0;

+    for (j = 0; j < idSize; j++)

+    {

+      id = ((id << 8) | *sd->Data);

+      sd->Data++;

+      sd->Size--;

+    }

+    if (id > (UInt32)0xFFFFFFFF)

+      return SZ_ERROR_UNSUPPORTED;

+    coder->MethodID = (UInt32)id;

+    

+    coder->NumInStreams = 1;

+    coder->NumOutStreams = 1;

+    coder->PropsOffset = 0;

+    coder->PropsSize = 0;

+    

+    if ((mainByte & 0x10) != 0)

+    {

+      UInt32 numStreams;

+      RINOK(SzReadNumber32(sd, &numStreams));

+      if (numStreams > NUM_CODER_STREAMS_MAX)

+        return SZ_ERROR_UNSUPPORTED;

+      coder->NumInStreams = (Byte)numStreams;

+      RINOK(SzReadNumber32(sd, &numStreams));

+      if (numStreams > NUM_CODER_STREAMS_MAX)

+        return SZ_ERROR_UNSUPPORTED;

+      coder->NumOutStreams = (Byte)numStreams;

+    }

+    if ((mainByte & 0x20) != 0)

+    {

+      UInt32 propsSize = 0;

+      RINOK(SzReadNumber32(sd, &propsSize));

+      if (propsSize >= 0x40)

+        return SZ_ERROR_UNSUPPORTED;

+      if (propsSize > sd->Size)

+        return SZ_ERROR_ARCHIVE;

+      coder->PropsOffset = sd->Data - dataStart;

+      coder->PropsSize = (Byte)propsSize;

+      sd->Data += (size_t)propsSize;

+      sd->Size -= (size_t)propsSize;

+    }

+    numInStreams += coder->NumInStreams;

+    numOutStreams += coder->NumOutStreams;

+  }

+

+  if (numOutStreams == 0)

+    return SZ_ERROR_UNSUPPORTED;

+

+  f->NumBindPairs = numBindPairs = numOutStreams - 1;

+  if (numInStreams < numBindPairs)

+    return SZ_ERROR_ARCHIVE;

+  if (numInStreams > SZ_NUM_IN_STREAMS_IN_FOLDER_MAX)

+    return SZ_ERROR_UNSUPPORTED;

+  f->MainOutStream = 0;

+  f->NumPackStreams = numPackStreams = numInStreams - numBindPairs;

+  if (numPackStreams > SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)

+    return SZ_ERROR_UNSUPPORTED;

+  for (i = 0; i < numInStreams; i++)

+    inStreamUsed[i] = False;

+  if (numBindPairs != 0)

+  {

+    Byte outStreamUsed[SZ_NUM_CODERS_OUT_STREAMS_IN_FOLDER_MAX];

+

+    if (numBindPairs > SZ_NUM_BINDS_IN_FOLDER_MAX)

+      return SZ_ERROR_UNSUPPORTED;

+

+    for (i = 0; i < numOutStreams; i++)

+      outStreamUsed[i] = False;

+

+    for (i = 0; i < numBindPairs; i++)

+    {

+      CSzBindPair *bp = f->BindPairs + i;

+      RINOK(SzReadNumber32(sd, &bp->InIndex));

+      if (bp->InIndex >= numInStreams)

+        return SZ_ERROR_ARCHIVE;

+      inStreamUsed[bp->InIndex] = True;

+      RINOK(SzReadNumber32(sd, &bp->OutIndex));

+      if (bp->OutIndex >= numInStreams)

+        return SZ_ERROR_ARCHIVE;

+      outStreamUsed[bp->OutIndex] = True;

+    }

+    for (i = 0; i < numOutStreams; i++)

+      if (!outStreamUsed[i])

+      {

+        f->MainOutStream = i;

+        break;

+      }

+    if (i == numOutStreams)

+      return SZ_ERROR_ARCHIVE;

+  }

+

+  if (numPackStreams == 1)

+  {

+    for (i = 0; i < numInStreams; i++)

+      if (!inStreamUsed[i])

+        break;

+    if (i == numInStreams)

+      return SZ_ERROR_ARCHIVE;

+    f->PackStreams[0] = i;

+  }

+  else

+    for (i = 0; i < numPackStreams; i++)

+    {

+      RINOK(SzReadNumber32(sd, f->PackStreams + i));

+    }

+

+  for (i = 0; i < numOutStreams; i++)

+  {

+    RINOK(ReadNumber(sdSizes, f->CodersUnpackSizes + i));

+  }

+  

+  return SZ_OK;

+}

+

+static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)

+{

+  CSzData sd;

+  sd = *sd2;

+  for (; num != 0; num--)

+  {

+    Byte firstByte, mask;

+    unsigned i;

+    SZ_READ_BYTE_2(firstByte);

+    if ((firstByte & 0x80) == 0)

+      continue;

+    if ((firstByte & 0x40) == 0)

+    {

+      if (sd.Size == 0)

+        return SZ_ERROR_ARCHIVE;

+      sd.Size--;

+      sd.Data++;

+      continue;

+    }

+    mask = 0x20;

+    for (i = 2; i < 8 && (firstByte & mask) != 0; i++)

+      mask >>= 1;

+    if (i > sd.Size)

+      return SZ_ERROR_ARCHIVE;

+    SKIP_DATA2(sd, i);

+  }

+  *sd2 = sd;

+  return SZ_OK;

+}

+

+#define k_InStreamUsed_MAX 64

+#define k_OutStreamUsed_MAX 64

+

+static SRes ReadUnpackInfo(CSzAr *p,

+    CSzData *sd2,

+    UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,

+    ISzAlloc *alloc)

+{

+  CSzData sd;

+  Byte inStreamUsed[k_InStreamUsed_MAX];

+  Byte outStreamUsed[k_OutStreamUsed_MAX];

+  UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;

+  const Byte *startBufPtr;

+  Byte external;

+  

+  RINOK(WaitId(sd2, k7zIdFolder));

+  RINOK(SzReadNumber32(sd2, &numFolders));

+  if (p->NumFolders > numFoldersMax)

+    return SZ_ERROR_UNSUPPORTED;

+  p->NumFolders = numFolders;

+

+  SZ_READ_BYTE_SD(sd2, external);

+  if (external == 0)

+    sd = *sd2;

+  else

+  {

+    UInt32 index;

+    SzReadNumber32(sd2, &index);

+    if (index >= numTempBufs)

+      return SZ_ERROR_ARCHIVE;

+    sd.Data = tempBufs[index].data;

+    sd.Size = tempBufs[index].size;

+  }

+  

+  MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc);

+  MY_ALLOC(size_t, p->FoSizesOffsets, (size_t)numFolders + 1, alloc);

+  MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc);

+  

+  startBufPtr = sd.Data;

+  

+  packStreamIndex = 0;

+  numCodersOutStreams = 0;

+

+  for (fo = 0; fo < numFolders; fo++)

+  {

+    UInt32 numCoders, ci, numInStreams = 0, numOutStreams = 0;

+    

+    p->FoCodersOffsets[fo] = sd.Data - startBufPtr;

+    RINOK(SzReadNumber32(&sd, &numCoders));

+    if (numCoders > NUM_FOLDER_CODERS_MAX)

+      return SZ_ERROR_UNSUPPORTED;

+    

+    for (ci = 0; ci < numCoders; ci++)

+    {

+      Byte mainByte;

+      unsigned idSize;

+      UInt32 coderInStreams, coderOutStreams;

+      

+      SZ_READ_BYTE_2(mainByte);

+      if ((mainByte & 0xC0) != 0)

+        return SZ_ERROR_UNSUPPORTED;

+      idSize = (mainByte & 0xF);

+      if (idSize > 8)

+        return SZ_ERROR_UNSUPPORTED;

+      if (idSize > sd.Size)

+        return SZ_ERROR_ARCHIVE;

+      SKIP_DATA2(sd, idSize);

+      

+      coderInStreams = 1;

+      coderOutStreams = 1;

+      if ((mainByte & 0x10) != 0)

+      {

+        RINOK(SzReadNumber32(&sd, &coderInStreams));

+        RINOK(SzReadNumber32(&sd, &coderOutStreams));

+        if (coderInStreams > NUM_CODER_STREAMS_MAX ||

+            coderOutStreams > NUM_CODER_STREAMS_MAX)

+          return SZ_ERROR_UNSUPPORTED;

+      }

+      numInStreams += coderInStreams;

+      numOutStreams += coderOutStreams;

+      if ((mainByte & 0x20) != 0)

+      {

+        UInt32 propsSize;

+        RINOK(SzReadNumber32(&sd, &propsSize));

+        if (propsSize > sd.Size)

+          return SZ_ERROR_ARCHIVE;

+        SKIP_DATA2(sd, propsSize);

+      }

+    }

+    

+    {

+      UInt32 indexOfMainStream = 0;

+      UInt32 numPackStreams = 1;

+      if (numOutStreams != 1 || numInStreams != 1)

+      {

+        UInt32 i;

+        UInt32 numBindPairs = numOutStreams - 1;

+        if (numOutStreams == 0 || numInStreams < numBindPairs)

+          return SZ_ERROR_ARCHIVE;

+        

+        if (numInStreams > k_InStreamUsed_MAX ||

+            numOutStreams > k_OutStreamUsed_MAX)

+          return SZ_ERROR_UNSUPPORTED;

+        

+        for (i = 0; i < numInStreams; i++)

+          inStreamUsed[i] = False;

+        for (i = 0; i < numOutStreams; i++)

+          outStreamUsed[i] = False;

+        

+        for (i = 0; i < numBindPairs; i++)

+        {

+          UInt32 index;

+          RINOK(SzReadNumber32(&sd, &index));

+          if (index >= numInStreams || inStreamUsed[index])

+            return SZ_ERROR_ARCHIVE;

+          inStreamUsed[index] = True;

+          RINOK(SzReadNumber32(&sd, &index));

+          if (index >= numInStreams || outStreamUsed[index])

+            return SZ_ERROR_ARCHIVE;

+          outStreamUsed[index] = True;

+        }

+        

+        numPackStreams = numInStreams - numBindPairs;

+        

+        if (numPackStreams != 1)

+          for (i = 0; i < numPackStreams; i++)

+          {

+            UInt32 temp;

+            RINOK(SzReadNumber32(&sd, &temp));

+            if (temp >= numInStreams)

+              return SZ_ERROR_ARCHIVE;

+          }

+          

+        for (i = 0; i < numOutStreams; i++)

+          if (!outStreamUsed[i])

+          {

+            indexOfMainStream = i;

+            break;

+          }

+ 

+        if (i == numOutStreams)

+          return SZ_ERROR_ARCHIVE;

+      }

+      p->FoStartPackStreamIndex[fo] = packStreamIndex;

+      p->FoSizesOffsets[fo] = (numOutStreams << 8) | indexOfMainStream;

+      numCodersOutStreams += numOutStreams;

+      if (numCodersOutStreams < numOutStreams)

+        return SZ_ERROR_UNSUPPORTED;

+      packStreamIndex += numPackStreams;

+      if (packStreamIndex < numPackStreams)

+        return SZ_ERROR_UNSUPPORTED;

+      if (packStreamIndex > p->NumPackStreams)

+        return SZ_ERROR_ARCHIVE;

+    }

+  }

+  

+  {

+    size_t dataSize = sd.Data - startBufPtr;

+    p->FoStartPackStreamIndex[fo] = packStreamIndex;

+    p->FoCodersOffsets[fo] = dataSize;

+    MY_ALLOC(Byte, p->CodersData, dataSize, alloc);

+    memcpy(p->CodersData, startBufPtr, dataSize);

+  }

+  

+  if (external != 0)

+  {

+    if (sd.Size != 0)

+      return SZ_ERROR_ARCHIVE;

+    sd = *sd2;

+  }

+  

+  RINOK(WaitId(&sd, k7zIdCodersUnpackSize));

+  

+  // MY_ALLOC(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc);

+  {

+    size_t dataSize = sd.Size;

+    /*

+    UInt32 i;

+    for (i = 0; i < numCodersOutStreams; i++)

+    {

+    RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i));

+    }

+    */

+    RINOK(SkipNumbers(&sd, numCodersOutStreams));

+    dataSize -= sd.Size;

+    MY_ALLOC(Byte, p->UnpackSizesData, dataSize, alloc);

+    memcpy(p->UnpackSizesData, sd.Data - dataSize, dataSize);

+    p->UnpackSizesDataSize = dataSize;

+    /*

+    const Byte *data = SzReadNumbers(sd.Data, sd.Data + sd.Size, p->CoderUnpackSizes, numCodersOutStreams);

+    if (data == NULL)

+    return SZ_ERROR_ARCHIVE;

+    sd.Size = sd.Data + sd.Size - data;

+    sd.Data = data;

+    */

+  }

+

+  for (;;)

+  {

+    UInt64 type;

+    RINOK(ReadID(&sd, &type));

+    if (type == k7zIdEnd)

+    {

+      *sd2 = sd;

+      return SZ_OK;

+    }

+    if (type == k7zIdCRC)

+    {

+      RINOK(ReadBitUi32s(&sd, numFolders, &p->FolderCRCs, alloc));

+      continue;

+    }

+    RINOK(SkipData(&sd));

+  }

+}

+

+typedef struct

+{

+  UInt32 NumTotalSubStreams;

+  UInt32 NumSubDigests;

+  CSzData sdNumSubStreams;

+  CSzData sdSizes;

+  CSzData sdCRCs;

+} CSubStreamInfo;

+

+#define SzUi32IndexMax (((UInt32)1 << 31) - 2)

+

+static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)

+{

+  UInt64 type = 0;

+  UInt32 i;

+  UInt32 numSubDigests = 0;

+  UInt32 numFolders = p->NumFolders;

+  UInt32 numUnpackStreams = numFolders;

+  UInt32 numUnpackSizesInData = 0;

+

+  for (;;)

+  {

+    RINOK(ReadID(sd, &type));

+    if (type == k7zIdNumUnpackStream)

+    {

+      ssi->sdNumSubStreams.Data = sd->Data;

+      numUnpackStreams = 0;

+      numSubDigests = 0;

+      for (i = 0; i < numFolders; i++)

+      {

+        UInt32 numStreams;

+        RINOK(SzReadNumber32(sd, &numStreams));

+        if (numUnpackStreams > numUnpackStreams + numStreams)

+          return SZ_ERROR_UNSUPPORTED;

+        numUnpackStreams += numStreams;

+        if (numStreams != 0)

+          numUnpackSizesInData += (numStreams - 1);

+        if (numStreams != 1 || !SzBitWithVals_Check(&p->FolderCRCs, i))

+          numSubDigests += numStreams;

+      }

+      ssi->sdNumSubStreams.Size = sd->Data - ssi->sdNumSubStreams.Data;

+      continue;

+    }

+    if (type == k7zIdCRC || type == k7zIdSize || type == k7zIdEnd)

+      break;

+    RINOK(SkipData(sd));

+  }

+

+  if (!ssi->sdNumSubStreams.Data)

+  {

+    numSubDigests = numFolders;

+    if (p->FolderCRCs.Defs)

+      numSubDigests = numFolders - CountDefinedBits(p->FolderCRCs.Defs, numFolders);

+  }

+  

+  ssi->NumTotalSubStreams = numUnpackStreams;

+  ssi->NumSubDigests = numSubDigests;

+

+  if (type == k7zIdSize)

+  {

+    ssi->sdSizes.Data = sd->Data;

+    RINOK(SkipNumbers(sd, numUnpackSizesInData));

+    ssi->sdSizes.Size = sd->Data - ssi->sdSizes.Data;

+    RINOK(ReadID(sd, &type));

+  }

+

+  for (;;)

+  {

+    if (type == k7zIdEnd)

+      return SZ_OK;

+    if (type == k7zIdCRC)

+    {

+      ssi->sdCRCs.Data = sd->Data;

+      RINOK(SkipBitUi32s(sd, numSubDigests));

+      ssi->sdCRCs.Size = sd->Data - ssi->sdCRCs.Data;

+    }

+    else

+    {

+      RINOK(SkipData(sd));

+    }

+    RINOK(ReadID(sd, &type));

+  }

+}

+

+static SRes SzReadStreamsInfo(CSzAr *p,

+    CSzData *sd,

+    UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,

+    UInt64 *dataOffset,

+    CSubStreamInfo *ssi,

+    ISzAlloc *alloc)

+{

+  UInt64 type;

+

+  SzData_Clear(&ssi->sdSizes);

+  SzData_Clear(&ssi->sdCRCs);

+  SzData_Clear(&ssi->sdNumSubStreams);

+

+  *dataOffset = 0;

+  RINOK(ReadID(sd, &type));

+  if (type == k7zIdPackInfo)

+  {

+    RINOK(ReadNumber(sd, dataOffset));

+    RINOK(ReadPackInfo(p, sd, alloc));

+    RINOK(ReadID(sd, &type));

+  }

+  if (type == k7zIdUnpackInfo)

+  {

+    RINOK(ReadUnpackInfo(p, sd, numFoldersMax, tempBufs, numTempBufs, alloc));

+    RINOK(ReadID(sd, &type));

+  }

+  if (type == k7zIdSubStreamsInfo)

+  {

+    RINOK(ReadSubStreamsInfo(p, sd, ssi));

+    RINOK(ReadID(sd, &type));

+  }

+  else

+  {

+    ssi->NumTotalSubStreams = p->NumFolders;

+    // ssi->NumSubDigests = 0;

+  }

+

+  return (type == k7zIdEnd ? SZ_OK : SZ_ERROR_UNSUPPORTED);

+}

+

+static SRes SzReadAndDecodePackedStreams(

+    ILookInStream *inStream,

+    CSzData *sd,

+    CBuf *tempBufs,

+    UInt32 numFoldersMax,

+    UInt64 baseOffset,

+    CSzAr *p,

+    ISzAlloc *allocTemp)

+{

+  UInt64 dataStartPos;

+  UInt32 fo;

+  CSubStreamInfo ssi;

+  CSzData sdCodersUnpSizes;

+

+  RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp));

+  

+  dataStartPos += baseOffset;

+  if (p->NumFolders == 0)

+    return SZ_ERROR_ARCHIVE;

+ 

+  sdCodersUnpSizes.Data = p->UnpackSizesData;

+  sdCodersUnpSizes.Size = p->UnpackSizesDataSize;

+  for (fo = 0; fo < p->NumFolders; fo++)

+    Buf_Init(tempBufs + fo);

+  for (fo = 0; fo < p->NumFolders; fo++)

+  {

+    CBuf *tempBuf = tempBufs + fo;

+    // folder = p->Folders;

+    // unpackSize = SzAr_GetFolderUnpackSize(p, 0);

+    UInt32 mix = (UInt32)p->FoSizesOffsets[fo];

+    UInt32 mainIndex = mix & 0xFF;

+    UInt32 numOutStreams = mix >> 8;

+    UInt32 si;

+    UInt64 unpackSize = 0;

+    p->FoSizesOffsets[fo] = sdCodersUnpSizes.Data - p->UnpackSizesData;

+    for (si = 0; si < numOutStreams; si++)

+    {

+      UInt64 curSize;

+      RINOK(ReadNumber(&sdCodersUnpSizes, &curSize));

+      if (si == mainIndex)

+      {

+        unpackSize = curSize;

+        break;

+      }

+    }

+    if (si == numOutStreams)

+      return SZ_ERROR_FAIL;

+    if ((size_t)unpackSize != unpackSize)

+      return SZ_ERROR_MEM;

+    if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp))

+      return SZ_ERROR_MEM;

+  }

+  p->FoSizesOffsets[fo] = sdCodersUnpSizes.Data - p->UnpackSizesData;

+    

+  for (fo = 0; fo < p->NumFolders; fo++)

+  {

+    const CBuf *tempBuf = tempBufs + fo;

+    RINOK(LookInStream_SeekTo(inStream, dataStartPos));

+    RINOK(SzAr_DecodeFolder(p, fo, inStream, dataStartPos, tempBuf->data, tempBuf->size, allocTemp));

+    if (SzBitWithVals_Check(&p->FolderCRCs, fo))

+      if (CrcCalc(tempBuf->data, tempBuf->size) != p->FolderCRCs.Vals[fo])

+        return SZ_ERROR_CRC;

+  }

+  return SZ_OK;

+}

+

+static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets)

+{

+  size_t pos = 0;

+  *offsets++ = 0;

+  if (numFiles == 0)

+    return (size == 0) ? SZ_OK : SZ_ERROR_ARCHIVE;

+  if (data[size - 2] != 0 || data[size - 1] != 0)

+    return SZ_ERROR_ARCHIVE;

+  do

+  {

+    const Byte *p;

+    if (pos == size)

+      return SZ_ERROR_ARCHIVE;

+    for (p = data + pos;

+      #ifdef _WIN32

+      *(const UInt16 *)p != 0

+      #else

+      p[0] != 0 || p[1] != 0

+      #endif

+      ; p += 2);

+    pos = p - data + 2;

+    *offsets++ = (pos >> 1);

+  }

+  while (--numFiles);

+  return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;

+}

+

+static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,

+    CSzData *sd2,

+    const CBuf *tempBufs, UInt32 numTempBufs,

+    ISzAlloc *alloc)

+{

+  CSzData sd;

+  UInt32 i;

+  CNtfsFileTime *vals;

+  Byte *defs;

+  Byte external;

+  RINOK(ReadBitVector(sd2, num, &p->Defs, alloc));

+  RINOK(SzReadByte(sd2, &external));

+  if (external == 0)

+    sd = *sd2;

+  else

+  {

+    UInt32 index;

+    SzReadNumber32(sd2, &index);

+    if (index >= numTempBufs)

+      return SZ_ERROR_ARCHIVE;

+    sd.Data = tempBufs[index].data;

+    sd.Size = tempBufs[index].size;

+  }

+  MY_ALLOC(CNtfsFileTime, p->Vals, num, alloc);

+  vals = p->Vals;

+  defs = p->Defs;

+  for (i = 0; i < num; i++)

+    if (SzBitArray_Check(defs, i))

+    {

+      if (sd.Size < 8)

+        return SZ_ERROR_ARCHIVE;

+      vals[i].Low = GetUi32(sd.Data);

+      vals[i].High = GetUi32(sd.Data + 4);

+      SKIP_DATA2(sd, 8);

+    }

+    else

+      vals[i].High = vals[i].Low = 0;

+  if (external == 0)

+    *sd2 = sd;

+  return SZ_OK;

+}

+

+#define NUM_ADDITIONAL_STREAMS_MAX 8

+

+static SRes SzReadHeader2(

+    CSzArEx *p,   /* allocMain */

+    CSzData *sd,

+    // Byte **emptyStreamVector, /* allocTemp */

+    // Byte **emptyFileVector,   /* allocTemp */

+    // Byte **lwtVector,         /* allocTemp */

+    ILookInStream *inStream,

+    CBuf *tempBufs,

+    UInt32 *numTempBufs,

+    ISzAlloc *allocMain,

+    ISzAlloc *allocTemp

+    )

+{

+  UInt64 type;

+  UInt32 numFiles = 0;

+  UInt32 numEmptyStreams = 0;

+  UInt32 i;

+  CSubStreamInfo ssi;

+  const Byte *emptyStreams = 0;

+  const Byte *emptyFiles = 0;

+

+  SzData_Clear(&ssi.sdSizes);

+  SzData_Clear(&ssi.sdCRCs);

+  SzData_Clear(&ssi.sdNumSubStreams);

+

+  ssi.NumSubDigests = 0;

+  ssi.NumTotalSubStreams = 0;

+

+  RINOK(ReadID(sd, &type));

+

+  if (type == k7zIdArchiveProperties)

+  {

+    for (;;)

+    {

+      UInt64 type;

+      RINOK(ReadID(sd, &type));

+      if (type == k7zIdEnd)

+        break;

+      RINOK(SkipData(sd));

+    }

+    RINOK(ReadID(sd, &type));

+  }

+

+  // if (type == k7zIdAdditionalStreamsInfo)     return SZ_ERROR_UNSUPPORTED;

+

+  if (type == k7zIdAdditionalStreamsInfo)

+  {

+    CSzAr tempAr;

+    SRes res;

+    UInt32 numTempFolders;

+    

+    SzAr_Init(&tempAr);

+    res = SzReadAndDecodePackedStreams(inStream, sd, tempBufs, NUM_ADDITIONAL_STREAMS_MAX,

+        p->startPosAfterHeader, &tempAr, allocTemp);

+    numTempFolders = tempAr.NumFolders;

+    SzAr_Free(&tempAr, allocTemp);

+    if (res != SZ_OK)

+      return res;

+    *numTempBufs = numTempFolders;

+    RINOK(ReadID(sd, &type));

+  }

+

+  if (type == k7zIdMainStreamsInfo)

+  {

+    RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs,

+        &p->dataPos, &ssi, allocMain));

+    p->dataPos += p->startPosAfterHeader;

+    RINOK(ReadID(sd, &type));

+  }

+

+  if (type == k7zIdEnd)

+  {

+    // *sd2 = sd;

+    return SZ_OK;

+  }

+  if (type != k7zIdFilesInfo)

+    return SZ_ERROR_ARCHIVE;

+  

+  RINOK(SzReadNumber32(sd, &numFiles));

+  p->NumFiles = numFiles;

+

+  for (;;)

+  {

+    UInt64 type;

+    UInt64 size;

+    RINOK(ReadID(sd, &type));

+    if (type == k7zIdEnd)

+      break;

+    RINOK(ReadNumber(sd, &size));

+    if (size > sd->Size)

+      return SZ_ERROR_ARCHIVE;

+    if ((UInt64)(int)type != type)

+    {

+      SKIP_DATA(sd, size);

+    }

+    else switch((int)type)

+    {

+      case k7zIdName:

+      {

+        size_t namesSize;

+        const Byte *namesData;

+        Byte external;

+

+        SZ_READ_BYTE(external);

+        if (external == 0)

+        {

+          namesSize = (size_t)size - 1;

+          namesData = sd->Data;

+        }

+        else

+        {

+          UInt32 index;

+          SzReadNumber32(sd, &index);

+          if (index >= *numTempBufs)

+            return SZ_ERROR_ARCHIVE;

+          namesData = (tempBufs)[index].data;

+          namesSize = (tempBufs)[index].size;

+        }

+

+        if ((namesSize & 1) != 0)

+          return SZ_ERROR_ARCHIVE;

+        MY_ALLOC(Byte, p->FileNames, namesSize, allocMain);

+        MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain);

+        memcpy(p->FileNames, namesData, namesSize);

+        RINOK(SzReadFileNames(p->FileNames, namesSize, numFiles, p->FileNameOffsets))

+        if (external == 0)

+        {

+          SKIP_DATA(sd, namesSize);

+        }

+        break;

+      }

+      case k7zIdEmptyStream:

+      {

+        RINOK(RememberBitVector(sd, numFiles, &emptyStreams));

+        numEmptyStreams = CountDefinedBits(emptyStreams, numFiles);

+        break;

+      }

+      case k7zIdEmptyFile:

+      {

+        RINOK(RememberBitVector(sd, numEmptyStreams, &emptyFiles));

+        break;

+      }

+      case k7zIdWinAttrib:

+      {

+        Byte external;

+        CSzData sdSwitch;

+        CSzData *sdPtr;

+        SzBitUi32s_Free(&p->Attribs, allocMain);

+        RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain));

+

+        SZ_READ_BYTE(external);

+        if (external == 0)

+          sdPtr = sd;

+        else

+        {

+          UInt32 index;

+          SzReadNumber32(sd, &index);

+          if (index >= *numTempBufs)

+            return SZ_ERROR_ARCHIVE;

+          sdSwitch.Data = (tempBufs)[index].data;

+          sdSwitch.Size = (tempBufs)[index].size;

+          sdPtr = &sdSwitch;

+        }

+        RINOK(ReadUi32s(sdPtr, numFiles, &p->Attribs, allocMain));

+        break;

+      }

+      /*

+      case k7zParent:

+      {

+        SzBitUi32s_Free(&p->Parents, allocMain);

+        RINOK(ReadBitVector(sd, numFiles, &p->Parents.Defs, allocMain));

+        RINOK(SzReadSwitch(sd));

+        RINOK(ReadUi32s(sd, numFiles, &p->Parents, allocMain));

+        break;

+      }

+      */

+      case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;

+      case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;

+      default:

+      {

+        SKIP_DATA(sd, size);

+      }

+    }

+  }

+

+  if (numFiles - numEmptyStreams != ssi.NumTotalSubStreams)

+    return SZ_ERROR_ARCHIVE;

+

+  for (;;)

+  {

+    UInt64 type;

+    RINOK(ReadID(sd, &type));

+    if (type == k7zIdEnd)

+      break;

+    RINOK(SkipData(sd));

+  }

+

+  {

+    UInt32 emptyFileIndex = 0;

+

+    UInt32 folderIndex = 0;

+    UInt32 indexInFolder = 0;

+    UInt64 unpackPos = 0;

+    const Byte *digestsDefs = 0;

+    const Byte *digestsVals = 0;

+    UInt32 digestsValsIndex = 0;

+    UInt32 digestIndex;

+    Byte allDigestsDefined = 0;

+    UInt32 curNumSubStreams = (UInt32)(Int32)-1;

+    Byte isDirMask = 0;

+    Byte crcMask = 0;

+    Byte mask = 0x80;

+    // size_t unpSizesOffset = 0;

+    CSzData sdCodersUnpSizes;

+    sdCodersUnpSizes.Data = p->db.UnpackSizesData;

+    sdCodersUnpSizes.Size = p->db.UnpackSizesDataSize;

+    

+    MY_ALLOC(UInt32, p->FolderStartFileIndex, p->db.NumFolders + 1, allocMain);

+    MY_ALLOC(UInt32, p->FileIndexToFolderIndexMap, p->NumFiles, allocMain);

+    MY_ALLOC(UInt64, p->UnpackPositions, p->NumFiles + 1, allocMain);

+    MY_ALLOC(Byte, p->IsDirs, (p->NumFiles + 7) >> 3, allocMain);

+

+    RINOK(SzBitUi32s_Alloc(&p->CRCs, p->NumFiles, allocMain));

+

+    if (ssi.sdCRCs.Size != 0)

+    {

+      RINOK(SzReadByte(&ssi.sdCRCs, &allDigestsDefined));

+      if (allDigestsDefined)

+        digestsVals = ssi.sdCRCs.Data;

+      else

+      {

+        size_t numBytes = (ssi.NumSubDigests + 7) >> 3;

+        digestsDefs = ssi.sdCRCs.Data;

+        digestsVals = digestsDefs + numBytes;

+      }

+    }

+

+    digestIndex = 0;

+    for (i = 0; i < numFiles; i++, mask >>= 1)

+    {

+      if (mask == 0)

+      {

+        UInt32 byteIndex = (i - 1) >> 3;

+        p->IsDirs[byteIndex] = isDirMask;

+        p->CRCs.Defs[byteIndex] = crcMask;

+        isDirMask = 0;

+        crcMask = 0;

+        mask = 0x80;

+      }

+

+      p->UnpackPositions[i] = unpackPos;

+      p->CRCs.Vals[i] = 0;

+      // p->CRCs.Defs[i] = 0;

+      if (emptyStreams && SzBitArray_Check(emptyStreams , i))

+      {

+        if (!emptyFiles || !SzBitArray_Check(emptyFiles, emptyFileIndex))

+          isDirMask |= mask;

+        emptyFileIndex++;

+        if (indexInFolder == 0)

+        {

+          p->FileIndexToFolderIndexMap[i] = (UInt32)-1;

+          continue;

+        }

+      }

+      if (indexInFolder == 0)

+      {

+        /*

+        v3.13 incorrectly worked with empty folders

+        v4.07: Loop for skipping empty folders

+        */

+        for (;;)

+        {

+          if (folderIndex >= p->db.NumFolders)

+            return SZ_ERROR_ARCHIVE;

+          p->FolderStartFileIndex[folderIndex] = i;

+          if (curNumSubStreams == (UInt32)(Int32)-1);

+          {

+            curNumSubStreams = 1;

+            if (ssi.sdNumSubStreams.Data != 0)

+            {

+              RINOK(SzReadNumber32(&ssi.sdNumSubStreams, &curNumSubStreams));

+            }

+          }

+          if (curNumSubStreams != 0)

+            break;

+          curNumSubStreams = (UInt32)(Int32)-1;

+          folderIndex++; // check it

+        }

+      }

+      p->FileIndexToFolderIndexMap[i] = folderIndex;

+      if (emptyStreams && SzBitArray_Check(emptyStreams , i))

+        continue;

+      

+      indexInFolder++;

+      if (indexInFolder >= curNumSubStreams)

+      {

+        UInt64 folderUnpackSize = 0;

+        UInt64 startFolderUnpackPos;

+        {

+          UInt32 mix = (UInt32)p->db.FoSizesOffsets[folderIndex];

+          UInt32 mainIndex = mix & 0xFF;

+          UInt32 numOutStreams = mix >> 8;

+          UInt32 si;

+          p->db.FoSizesOffsets[folderIndex] = sdCodersUnpSizes.Data - p->db.UnpackSizesData;

+          for (si = 0; si < numOutStreams; si++)

+          {

+            UInt64 curSize;

+            RINOK(ReadNumber(&sdCodersUnpSizes, &curSize));

+            if (si == mainIndex)

+            {

+              folderUnpackSize = curSize;

+              break;

+            }

+          }

+          if (si == numOutStreams)

+            return SZ_ERROR_FAIL;

+        }

+

+        // UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);

+        startFolderUnpackPos = p->UnpackPositions[p->FolderStartFileIndex[folderIndex]];

+        if (folderUnpackSize < unpackPos - startFolderUnpackPos)

+          return SZ_ERROR_ARCHIVE;

+        unpackPos = startFolderUnpackPos + folderUnpackSize;

+

+        if (curNumSubStreams == 1 && SzBitWithVals_Check(&p->db.FolderCRCs, i))

+        {

+          p->CRCs.Vals[i] = p->db.FolderCRCs.Vals[folderIndex];

+          crcMask |= mask;

+        }

+        else if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))

+        {

+          p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);

+          digestsValsIndex++;

+          crcMask |= mask;

+        }

+        folderIndex++;

+        indexInFolder = 0;

+      }

+      else

+      {

+        UInt64 v;

+        RINOK(ReadNumber(&ssi.sdSizes, &v));

+        unpackPos += v;

+        if (allDigestsDefined || (digestsDefs && SzBitArray_Check(digestsDefs, digestIndex)))

+        {

+          p->CRCs.Vals[i] = GetUi32(digestsVals + (size_t)digestsValsIndex * 4);

+          digestsValsIndex++;

+          crcMask |= mask;

+        }

+      }

+    }

+    if (mask != 0x80)

+    {

+      UInt32 byteIndex = (i - 1) >> 3;

+      p->IsDirs[byteIndex] = isDirMask;

+      p->CRCs.Defs[byteIndex] = crcMask;

+    }

+    p->UnpackPositions[i] = unpackPos;

+    p->FolderStartFileIndex[folderIndex] = i;

+    p->db.FoSizesOffsets[folderIndex] = sdCodersUnpSizes.Data - p->db.UnpackSizesData;

+  }

+  return SZ_OK;

+}

+

+static SRes SzReadHeader(

+    CSzArEx *p,

+    CSzData *sd,

+    ILookInStream *inStream,

+    ISzAlloc *allocMain

+    ,ISzAlloc *allocTemp

+    )

+{

+  // Byte *emptyStreamVector = 0;

+  // Byte *emptyFileVector = 0;

+  // Byte *lwtVector = 0;

+  UInt32 i;

+  UInt32 numTempBufs = 0;

+  SRes res;

+  CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX];

+

+  for (i = 0; i < NUM_ADDITIONAL_STREAMS_MAX; i++)

+    Buf_Init(tempBufs + i);

+  // SzBitUi32s_Init(&digests);

+  

+  res = SzReadHeader2(p, sd,

+      // &emptyStreamVector,

+      // &emptyFileVector,

+      // &lwtVector,

+      inStream,

+      tempBufs, &numTempBufs,

+      allocMain, allocTemp

+      );

+  

+  for (i = 0; i < numTempBufs; i++)

+    Buf_Free(tempBufs + i, allocTemp);

+

+  // IAlloc_Free(allocTemp, emptyStreamVector);

+  // IAlloc_Free(allocTemp, emptyFileVector);

+  // IAlloc_Free(allocTemp, lwtVector);

+

+  RINOK(res);

+  {

+    if (sd->Size != 0)

+      return SZ_ERROR_FAIL;

+  }

+

+  return res;

+}

+

+/*

+static UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)

+{

+  const CSzFolder2 *f = p->Folders + folderIndex;

+

+  // return p->CoderUnpackSizes[f->StartCoderUnpackSizesIndex + f->IndexOfMainOutStream];

+

+  UInt32 si;

+  CSzData sdCodersUnpSizes;

+  sdCodersUnpSizes.Data = p->UnpackSizesData + f->UnpackSizeDataOffset;

+  sdCodersUnpSizes.Size = p->UnpackSizesDataSize - f->UnpackSizeDataOffset;

+  for (si = 0; si < numOutStreams; si++)

+  {

+    UInt64 curSize;

+    ReadNumber(&sdCodersUnpSizes, &curSize);

+    if (si == mainIndex)

+      return curSize;

+  }

+  return 0;

+}

+*/

+

+static SRes SzArEx_Open2(

+    CSzArEx *p,

+    ILookInStream *inStream,

+    ISzAlloc *allocMain,

+    ISzAlloc *allocTemp)

+{

+  Byte header[k7zStartHeaderSize];

+  Int64 startArcPos;

+  UInt64 nextHeaderOffset, nextHeaderSize;

+  size_t nextHeaderSizeT;

+  UInt32 nextHeaderCRC;

+  CBuf buf;

+  SRes res;

+

+  startArcPos = 0;

+  RINOK(inStream->Seek(inStream, &startArcPos, SZ_SEEK_CUR));

+

+  RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE));

+

+  if (!TestSignatureCandidate(header))

+    return SZ_ERROR_NO_ARCHIVE;

+  if (header[6] != k7zMajorVersion)

+    return SZ_ERROR_UNSUPPORTED;

+

+  nextHeaderOffset = GetUi64(header + 12);

+  nextHeaderSize = GetUi64(header + 20);

+  nextHeaderCRC = GetUi32(header + 28);

+

+  p->startPosAfterHeader = startArcPos + k7zStartHeaderSize;

+  

+  if (CrcCalc(header + 12, 20) != GetUi32(header + 8))

+    return SZ_ERROR_CRC;

+

+  nextHeaderSizeT = (size_t)nextHeaderSize;

+  if (nextHeaderSizeT != nextHeaderSize)

+    return SZ_ERROR_MEM;

+  if (nextHeaderSizeT == 0)

+    return SZ_OK;

+  if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||

+      nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)

+    return SZ_ERROR_NO_ARCHIVE;

+

+  {

+    Int64 pos = 0;

+    RINOK(inStream->Seek(inStream, &pos, SZ_SEEK_END));

+    if ((UInt64)pos < startArcPos + nextHeaderOffset ||

+        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||

+        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)

+      return SZ_ERROR_INPUT_EOF;

+  }

+

+  RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset));

+

+  if (!Buf_Create(&buf, nextHeaderSizeT, allocTemp))

+    return SZ_ERROR_MEM;

+

+  res = LookInStream_Read(inStream, buf.data, nextHeaderSizeT);

+  if (res == SZ_OK)

+  {

+    res = SZ_ERROR_ARCHIVE;

+    if (CrcCalc(buf.data, nextHeaderSizeT) == nextHeaderCRC)

+    {

+      CSzData sd;

+      UInt64 type;

+      sd.Data = buf.data;

+      sd.Size = buf.size;

+      res = ReadID(&sd, &type);

+      if (res == SZ_OK && type == k7zIdEncodedHeader)

+      {

+        CSzAr tempAr;

+        CBuf tempBuf;

+        Buf_Init(&tempBuf);

+        

+        SzAr_Init(&tempAr);

+        res = SzReadAndDecodePackedStreams(inStream, &sd, &tempBuf, 1, p->startPosAfterHeader, &tempAr, allocTemp);

+        SzAr_Free(&tempAr, allocTemp);

+       

+        if (res != SZ_OK)

+        {

+          Buf_Free(&tempBuf, allocTemp);

+        }

+        else

+        {

+          Buf_Free(&buf, allocTemp);

+          buf.data = tempBuf.data;

+          buf.size = tempBuf.size;

+          sd.Data = buf.data;

+          sd.Size = buf.size;

+          res = ReadID(&sd, &type);

+        }

+      }

+      if (res == SZ_OK)

+      {

+        if (type == k7zIdHeader)

+        {

+          CSzData sd2;

+          int ttt;

+          for (ttt = 0; ttt < 1; ttt++)

+          // for (ttt = 0; ttt < 40000; ttt++)

+          {

+            SzArEx_Free(p, allocMain);

+            sd2 = sd;

+            res = SzReadHeader(p, &sd2, inStream, allocMain, allocTemp

+              );

+            if (res != SZ_OK)

+              break;

+          }

+

+          // res = SzReadHeader(p, &sd, allocMain, allocTemp);

+        }

+        else

+          res = SZ_ERROR_UNSUPPORTED;

+      }

+    }

+  }

+  Buf_Free(&buf, allocTemp);

+  return res;

+}

+

+// #include <stdio.h>

+

+SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,

+    ISzAlloc *allocMain, ISzAlloc *allocTemp)

+{

+  SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);

+  if (res != SZ_OK)

+    SzArEx_Free(p, allocMain);

+  // printf ("\nrrr=%d\n", rrr);

+  return res;

+}

+

+SRes SzArEx_Extract(

+    const CSzArEx *p,

+    ILookInStream *inStream,

+    UInt32 fileIndex,

+    UInt32 *blockIndex,

+    Byte **tempBuf,

+    size_t *outBufferSize,

+    size_t *offset,

+    size_t *outSizeProcessed,

+    ISzAlloc *allocMain,

+    ISzAlloc *allocTemp)

+{

+  UInt32 folderIndex = p->FileIndexToFolderIndexMap[fileIndex];

+  SRes res = SZ_OK;

+  *offset = 0;

+  *outSizeProcessed = 0;

+  if (folderIndex == (UInt32)-1)

+  {

+    IAlloc_Free(allocMain, *tempBuf);

+    *blockIndex = folderIndex;

+    *tempBuf = 0;

+    *outBufferSize = 0;

+    return SZ_OK;

+  }

+

+  if (*tempBuf == 0 || *blockIndex != folderIndex)

+  {

+    // UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);

+    UInt64 unpackSizeSpec =

+        p->UnpackPositions[p->FolderStartFileIndex[folderIndex + 1]] -

+        p->UnpackPositions[p->FolderStartFileIndex[folderIndex]];

+    size_t unpackSize = (size_t)unpackSizeSpec;

+

+    if (unpackSize != unpackSizeSpec)

+      return SZ_ERROR_MEM;

+    *blockIndex = folderIndex;

+    IAlloc_Free(allocMain, *tempBuf);

+    *tempBuf = 0;

+    

+    // RINOK(LookInStream_SeekTo(inStream, startOffset));

+    

+    if (res == SZ_OK)

+    {

+      *outBufferSize = unpackSize;

+      if (unpackSize != 0)

+      {

+        *tempBuf = (Byte *)IAlloc_Alloc(allocMain, unpackSize);

+        if (*tempBuf == 0)

+          res = SZ_ERROR_MEM;

+      }

+      if (res == SZ_OK)

+      {

+        res = SzAr_DecodeFolder(&p->db, folderIndex,

+          inStream,

+          p->dataPos,

+          *tempBuf, unpackSize, allocTemp);

+        if (res == SZ_OK)

+        {

+          if (SzBitWithVals_Check(&p->db.FolderCRCs, folderIndex))

+          {

+            if (CrcCalc(*tempBuf, unpackSize) != p->db.FolderCRCs.Vals[folderIndex])

+              res = SZ_ERROR_CRC;

+          }

+        }

+      }

+    }

+  }

+  if (res == SZ_OK)

+  {

+    UInt64 unpackPos = p->UnpackPositions[fileIndex];

+    *offset = (size_t)(unpackPos - p->UnpackPositions[p->FolderStartFileIndex[folderIndex]]);

+    *outSizeProcessed = (size_t)(p->UnpackPositions[fileIndex + 1] - unpackPos);

+    if (*offset + *outSizeProcessed > *outBufferSize)

+      return SZ_ERROR_FAIL;

+    if (SzBitWithVals_Check(&p->CRCs, fileIndex) && CrcCalc(*tempBuf + *offset, *outSizeProcessed) != p->CRCs.Vals[fileIndex])

+      res = SZ_ERROR_CRC;

+  }

+  return res;

+}

+

+

+size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)

+{

+  size_t offs = p->FileNameOffsets[fileIndex];

+  size_t len = p->FileNameOffsets[fileIndex + 1] - offs;

+  if (dest != 0)

+  {

+    size_t i;

+    const Byte *src = p->FileNames + offs * 2;

+    for (i = 0; i < len; i++)

+      dest[i] = GetUi16(src + i * 2);

+  }

+  return len;

+}

+

+/*

+size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex)

+{

+  size_t len;

+  if (!p->FileNameOffsets)

+    return 1;

+  len = 0;

+  for (;;)

+  {

+    UInt32 parent = (UInt32)(Int32)-1;

+    len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];

+    if SzBitWithVals_Check(&p->Parents, fileIndex)

+      parent = p->Parents.Vals[fileIndex];

+    if (parent == (UInt32)(Int32)-1)

+      return len;

+    fileIndex = parent;

+  }

+}

+

+UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest)

+{

+  Bool needSlash;

+  if (!p->FileNameOffsets)

+  {

+    *(--dest) = 0;

+    return dest;

+  }

+  needSlash = False;

+  for (;;)

+  {

+    UInt32 parent = (UInt32)(Int32)-1;

+    size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];

+    SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen);

+    if (needSlash)

+      *(dest - 1) = '/';

+    needSlash = True;

+    dest -= curLen;

+

+    if SzBitWithVals_Check(&p->Parents, fileIndex)

+      parent = p->Parents.Vals[fileIndex];

+    if (parent == (UInt32)(Int32)-1)

+      return dest;

+    fileIndex = parent;

+  }

+}

+*/

diff --git a/C/7zBuf.c b/C/7zBuf.c
index a35fa2f..b0ac110 100755..100644
--- a/C/7zBuf.c
+++ b/C/7zBuf.c
@@ -1,7 +1,7 @@
 /* 7zBuf.c -- Byte Buffer

-2008-03-28

-Igor Pavlov

-Public domain */

+2013-01-21 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include "7zBuf.h"

 

diff --git a/C/7zBuf.h b/C/7zBuf.h
index 88ff0c2..e5f9218 100755..100644
--- a/C/7zBuf.h
+++ b/C/7zBuf.h
@@ -1,14 +1,12 @@
 /* 7zBuf.h -- Byte Buffer

-2009-02-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __7Z_BUF_H

 #define __7Z_BUF_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 typedef struct

 {

@@ -32,8 +30,6 @@ void DynBuf_SeekToBeg(CDynBuf *p);
 int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc);

 void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/7zBuf2.c b/C/7zBuf2.c
index 1c8b931..9633796 100755..100644
--- a/C/7zBuf2.c
+++ b/C/7zBuf2.c
@@ -1,7 +1,10 @@
 /* 7zBuf2.c -- Byte Buffer

-2008-10-04 : Igor Pavlov : Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include <string.h>

+

 #include "7zBuf.h"

 

 void DynBuf_Construct(CDynBuf *p)

diff --git a/C/7zCrc.c b/C/7zCrc.c
index 5801dab..161d4d1 100755..100644
--- a/C/7zCrc.c
+++ b/C/7zCrc.c
@@ -1,41 +1,33 @@
-/* 7zCrc.c -- CRC32 calculation

-2009-11-23 : Igor Pavlov : Public domain */

+/* 7zCrc.c -- CRC32 init

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include "7zCrc.h"

 #include "CpuArch.h"

 

 #define kCrcPoly 0xEDB88320

 

-#ifdef MY_CPU_LE

-#define CRC_NUM_TABLES 8

+#ifdef MY_CPU_X86_OR_AMD64

+  #define CRC_NUM_TABLES 8

+  UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);

+#elif defined(MY_CPU_LE)

+  #define CRC_NUM_TABLES 4

 #else

-#define CRC_NUM_TABLES 1

+  #define CRC_NUM_TABLES 5

+  #define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))

+  UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);

+#endif

+

+#ifndef MY_CPU_BE

+  UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);

 #endif

 

 typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);

 

-static CRC_FUNC g_CrcUpdate;

+CRC_FUNC g_CrcUpdate;

 UInt32 g_CrcTable[256 * CRC_NUM_TABLES];

 

-#if CRC_NUM_TABLES == 1

-

-#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))

-

-static UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)

-{

-  const Byte *p = (const Byte *)data;

-  for (; size > 0; size--, p++)

-    v = CRC_UPDATE_BYTE_2(v, *p);

-  return v;

-}

-

-#else

-

-UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);

-UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);

-

-#endif

-

 UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)

 {

   return g_CrcUpdate(v, data, size, g_CrcTable);

@@ -57,18 +49,37 @@ void MY_FAST_CALL CrcGenerateTable()
       r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));

     g_CrcTable[i] = r;

   }

-  #if CRC_NUM_TABLES == 1

-  g_CrcUpdate = CrcUpdateT1;

-  #else

   for (; i < 256 * CRC_NUM_TABLES; i++)

   {

     UInt32 r = g_CrcTable[i - 256];

     g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);

   }

+  

+  #ifdef MY_CPU_LE

+

   g_CrcUpdate = CrcUpdateT4;

-  #ifdef MY_CPU_X86_OR_AMD64

+  

+  #if CRC_NUM_TABLES == 8

   if (!CPU_Is_InOrder())

     g_CrcUpdate = CrcUpdateT8;

   #endif

+

+  #else

+  {

+    #ifndef MY_CPU_BE

+    UInt32 k = 1;

+    if (*(const Byte *)&k == 1)

+      g_CrcUpdate = CrcUpdateT4;

+    else

+    #endif

+    {

+      for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)

+      {

+        UInt32 x = g_CrcTable[i - 256];

+        g_CrcTable[i] = CRC_UINT32_SWAP(x);

+      }

+      g_CrcUpdate = CrcUpdateT1_BeT4;

+    }

+  }

   #endif

 }

diff --git a/C/7zCrc.h b/C/7zCrc.h
index 4a1ec38..3b04594 100755..100644
--- a/C/7zCrc.h
+++ b/C/7zCrc.h
@@ -1,10 +1,10 @@
 /* 7zCrc.h -- CRC32 calculation

-2009-11-21 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __7Z_CRC_H

 #define __7Z_CRC_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

 EXTERN_C_BEGIN

 

diff --git a/C/7zCrcOpt.c b/C/7zCrcOpt.c
index 6205d71..48b0136 100755..100644
--- a/C/7zCrcOpt.c
+++ b/C/7zCrcOpt.c
@@ -1,12 +1,14 @@
-/* 7zCrcOpt.c -- CRC32 calculation : optimized version

-2009-11-23 : Igor Pavlov : Public domain */

+/* 7zCrcOpt.c -- CRC32 calculation

+2013-11-12 : Igor Pavlov : Public domain */

 

-#include "CpuArch.h"

+#include "Precomp.h"

 

-#ifdef MY_CPU_LE

+#include "CpuArch.h"

 

 #define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))

 

+#ifndef MY_CPU_BE

+

 UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table)

 {

   const Byte *p = (const Byte *)data;

@@ -32,3 +34,33 @@ UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const U
 }

 

 #endif

+

+

+#ifndef MY_CPU_LE

+

+#define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))

+

+UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)

+{

+  const Byte *p = (const Byte *)data;

+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)

+    v = CRC_UPDATE_BYTE_2(v, *p);

+  v = CRC_UINT32_SWAP(v);

+  table += 0x100;

+  for (; size >= 4; size -= 4, p += 4)

+  {

+    v ^= *(const UInt32 *)p;

+    v =

+      table[0x000 + (v & 0xFF)] ^

+      table[0x100 + ((v >> 8) & 0xFF)] ^

+      table[0x200 + ((v >> 16) & 0xFF)] ^

+      table[0x300 + ((v >> 24))];

+  }

+  table -= 0x100;

+  v = CRC_UINT32_SWAP(v);

+  for (; size > 0; size--, p++)

+    v = CRC_UPDATE_BYTE_2(v, *p);

+  return v;

+}

+

+#endif

diff --git a/C/7zDec.c b/C/7zDec.c
index 3386807..1c363a5 100755..100644
--- a/C/7zDec.c
+++ b/C/7zDec.c
@@ -1,5 +1,7 @@
 /* 7zDec.c -- Decoding from 7z folder

-2010-11-02 : Igor Pavlov : Public domain */

+2014-06-16 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include <string.h>

 

@@ -63,7 +65,7 @@ static Byte ReadByte(void *pp)
   return 0;

 }

 

-static SRes SzDecodePpmd(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream,

+static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,

     Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)

 {

   CPpmd7 ppmd;

@@ -77,12 +79,12 @@ static SRes SzDecodePpmd(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
   s.res = SZ_OK;

   s.processed = 0;

 

-  if (coder->Props.size != 5)

+  if (propsSize != 5)

     return SZ_ERROR_UNSUPPORTED;

 

   {

-    unsigned order = coder->Props.data[0];

-    UInt32 memSize = GetUi32(coder->Props.data + 1);

+    unsigned order = props[0];

+    UInt32 memSize = GetUi32(props + 1);

     if (order < PPMD7_MIN_ORDER ||

         order > PPMD7_MAX_ORDER ||

         memSize < PPMD7_MIN_MEM_SIZE ||

@@ -124,14 +126,14 @@ static SRes SzDecodePpmd(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
 #endif

 

 

-static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream,

+static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,

     Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)

 {

   CLzmaDec state;

   SRes res = SZ_OK;

 

   LzmaDec_Construct(&state);

-  RINOK(LzmaDec_AllocateProbs(&state, coder->Props.data, (unsigned)coder->Props.size, allocMain));

+  RINOK(LzmaDec_AllocateProbs(&state, props, propsSize, allocMain));

   state.dic = outBuffer;

   state.dicBufSize = outSize;

   LzmaDec_Init(&state);

@@ -172,16 +174,16 @@ static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
   return res;

 }

 

-static SRes SzDecodeLzma2(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream,

+static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,

     Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)

 {

   CLzma2Dec state;

   SRes res = SZ_OK;

 

   Lzma2Dec_Construct(&state);

-  if (coder->Props.size != 1)

+  if (propsSize != 1)

     return SZ_ERROR_DATA;

-  RINOK(Lzma2Dec_AllocateProbs(&state, coder->Props.data[0], allocMain));

+  RINOK(Lzma2Dec_AllocateProbs(&state, props[0], allocMain));

   state.decoder.dic = outBuffer;

   state.decoder.dicBufSize = outSize;

   Lzma2Dec_Init(&state);

@@ -242,7 +244,7 @@ static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer
 

 static Bool IS_MAIN_METHOD(UInt32 m)

 {

-  switch(m)

+  switch (m)

   {

     case k_Copy:

     case k_LZMA:

@@ -260,7 +262,7 @@ static Bool IS_SUPPORTED_CODER(const CSzCoderInfo *c)
   return

       c->NumInStreams == 1 &&

       c->NumOutStreams == 1 &&

-      c->MethodID <= (UInt32)0xFFFFFFFF &&

+      /* c->MethodID <= (UInt32)0xFFFFFFFF && */

       IS_MAIN_METHOD((UInt32)c->MethodID);

 }

 

@@ -280,8 +282,9 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
   }

   if (f->NumCoders == 2)

   {

-    CSzCoderInfo *c = &f->Coders[1];

-    if (c->MethodID > (UInt32)0xFFFFFFFF ||

+    const CSzCoderInfo *c = &f->Coders[1];

+    if (

+        /* c->MethodID > (UInt32)0xFFFFFFFF || */

         c->NumInStreams != 1 ||

         c->NumOutStreams != 1 ||

         f->NumPackStreams != 1 ||

@@ -321,18 +324,12 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
   return SZ_ERROR_UNSUPPORTED;

 }

 

-static UInt64 GetSum(const UInt64 *values, UInt32 index)

-{

-  UInt64 sum = 0;

-  UInt32 i;

-  for (i = 0; i < index; i++)

-    sum += values[i];

-  return sum;

-}

-

 #define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break;

 

-static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,

+static SRes SzFolder_Decode2(const CSzFolder *folder,

+    const Byte *propsData,

+    const UInt64 *unpackSizes,

+    const UInt64 *packPositions,

     ILookInStream *inStream, UInt64 startPos,

     Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain,

     Byte *tempBuf[])

@@ -346,7 +343,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
 

   for (ci = 0; ci < folder->NumCoders; ci++)

   {

-    CSzCoderInfo *coder = &folder->Coders[ci];

+    const CSzCoderInfo *coder = &folder->Coders[ci];

 

     if (IS_MAIN_METHOD((UInt32)coder->MethodID))

     {

@@ -358,7 +355,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
       if (folder->NumCoders == 4)

       {

         UInt32 indices[] = { 3, 2, 0 };

-        UInt64 unpackSize = folder->UnpackSizes[ci];

+        UInt64 unpackSize = unpackSizes[ci];

         si = indices[ci];

         if (ci < 2)

         {

@@ -382,8 +379,8 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
         else

           return SZ_ERROR_UNSUPPORTED;

       }

-      offset = GetSum(packSizes, si);

-      inSize = packSizes[si];

+      offset = packPositions[si];

+      inSize = packPositions[si + 1] - offset;

       RINOK(LookInStream_SeekTo(inStream, startPos + offset));

 

       if (coder->MethodID == k_Copy)

@@ -394,16 +391,16 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
       }

       else if (coder->MethodID == k_LZMA)

       {

-        RINOK(SzDecodeLzma(coder, inSize, inStream, outBufCur, outSizeCur, allocMain));

+        RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));

       }

       else if (coder->MethodID == k_LZMA2)

       {

-        RINOK(SzDecodeLzma2(coder, inSize, inStream, outBufCur, outSizeCur, allocMain));

+        RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));

       }

       else

       {

         #ifdef _7ZIP_PPMD_SUPPPORT

-        RINOK(SzDecodePpmd(coder, inSize, inStream, outBufCur, outSizeCur, allocMain));

+        RINOK(SzDecodePpmd(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));

         #else

         return SZ_ERROR_UNSUPPORTED;

         #endif

@@ -411,8 +408,8 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
     }

     else if (coder->MethodID == k_BCJ2)

     {

-      UInt64 offset = GetSum(packSizes, 1);

-      UInt64 s3Size = packSizes[1];

+      UInt64 offset = packPositions[1];

+      UInt64 s3Size = packPositions[2] - offset;

       SRes res;

       if (ci != 3)

         return SZ_ERROR_UNSUPPORTED;

@@ -438,7 +435,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
     {

       if (ci != 1)

         return SZ_ERROR_UNSUPPORTED;

-      switch(coder->MethodID)

+      switch (coder->MethodID)

       {

         case k_BCJ:

         {

@@ -456,15 +453,41 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
   return SZ_OK;

 }

 

-SRes SzFolder_Decode(const CSzFolder *folder, const UInt64 *packSizes,

+SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,

     ILookInStream *inStream, UInt64 startPos,

-    Byte *outBuffer, size_t outSize, ISzAlloc *allocMain)

+    Byte *outBuffer, size_t outSize,

+    ISzAlloc *allocMain)

 {

-  Byte *tempBuf[3] = { 0, 0, 0};

-  int i;

-  SRes res = SzFolder_Decode2(folder, packSizes, inStream, startPos,

-      outBuffer, (SizeT)outSize, allocMain, tempBuf);

-  for (i = 0; i < 3; i++)

-    IAlloc_Free(allocMain, tempBuf[i]);

-  return res;

+  SRes res;

+  CSzFolder folder;

+  CSzData sd;

+  CSzData sdSizes;

+  

+  const Byte *data = p->CodersData + p->FoCodersOffsets[folderIndex];

+  sd.Data = data;

+  sd.Size = p->FoCodersOffsets[folderIndex + 1] - p->FoCodersOffsets[folderIndex];

+  

+  sdSizes.Data = p->UnpackSizesData + p->FoSizesOffsets[folderIndex];

+  sdSizes.Size =

+      p->FoSizesOffsets[folderIndex + 1] -

+      p->FoSizesOffsets[folderIndex];

+

+  res = SzGetNextFolderItem(&folder, &sd, &sdSizes);

+  

+  if (res != SZ_OK)

+    return res;

+

+  if (sd.Size != 0 || outSize != folder.CodersUnpackSizes[folder.MainOutStream])

+    return SZ_ERROR_FAIL;

+  {

+    int i;

+    Byte *tempBuf[3] = { 0, 0, 0};

+    res = SzFolder_Decode2(&folder, data, folder.CodersUnpackSizes,

+        p->PackPositions + p->FoStartPackStreamIndex[folderIndex],

+        inStream, startPos,

+        outBuffer, (SizeT)outSize, allocMain, tempBuf);

+    for (i = 0; i < 3; i++)

+      IAlloc_Free(allocMain, tempBuf[i]);

+    return res;

+  }

 }

diff --git a/C/7zFile.c b/C/7zFile.c
index 6d82c79..98fe716 100755..100644
--- a/C/7zFile.c
+++ b/C/7zFile.c
@@ -1,6 +1,8 @@
 /* 7zFile.c -- File IO

 2009-11-24 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include "7zFile.h"

 

 #ifndef USE_WINDOWS_FILE

diff --git a/C/7zFile.h b/C/7zFile.h
index 5d85787..d62a192 100755..100644
--- a/C/7zFile.h
+++ b/C/7zFile.h
@@ -1,5 +1,5 @@
 /* 7zFile.h -- File IO

-2009-11-24 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __7Z_FILE_H

 #define __7Z_FILE_H

@@ -14,7 +14,7 @@
 #include <stdio.h>

 #endif

 

-#include "Types.h"

+#include "7zTypes.h"

 

 EXTERN_C_BEGIN

 

diff --git a/C/7zIn.c b/C/7zIn.c
deleted file mode 100755
index f1a4492..0000000
--- a/C/7zIn.c
+++ /dev/null
@@ -1,1402 +0,0 @@
-/* 7zIn.c -- 7z Input functions

-2010-10-29 : Igor Pavlov : Public domain */

-

-#include <string.h>

-

-#include "7z.h"

-#include "7zCrc.h"

-#include "CpuArch.h"

-

-Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};

-

-#define RINOM(x) { if ((x) == 0) return SZ_ERROR_MEM; }

-

-#define NUM_FOLDER_CODERS_MAX 32

-#define NUM_CODER_STREAMS_MAX 32

-

-void SzCoderInfo_Init(CSzCoderInfo *p)

-{

-  Buf_Init(&p->Props);

-}

-

-void SzCoderInfo_Free(CSzCoderInfo *p, ISzAlloc *alloc)

-{

-  Buf_Free(&p->Props, alloc);

-  SzCoderInfo_Init(p);

-}

-

-void SzFolder_Init(CSzFolder *p)

-{

-  p->Coders = 0;

-  p->BindPairs = 0;

-  p->PackStreams = 0;

-  p->UnpackSizes = 0;

-  p->NumCoders = 0;

-  p->NumBindPairs = 0;

-  p->NumPackStreams = 0;

-  p->UnpackCRCDefined = 0;

-  p->UnpackCRC = 0;

-  p->NumUnpackStreams = 0;

-}

-

-void SzFolder_Free(CSzFolder *p, ISzAlloc *alloc)

-{

-  UInt32 i;

-  if (p->Coders)

-    for (i = 0; i < p->NumCoders; i++)

-      SzCoderInfo_Free(&p->Coders[i], alloc);

-  IAlloc_Free(alloc, p->Coders);

-  IAlloc_Free(alloc, p->BindPairs);

-  IAlloc_Free(alloc, p->PackStreams);

-  IAlloc_Free(alloc, p->UnpackSizes);

-  SzFolder_Init(p);

-}

-

-UInt32 SzFolder_GetNumOutStreams(CSzFolder *p)

-{

-  UInt32 result = 0;

-  UInt32 i;

-  for (i = 0; i < p->NumCoders; i++)

-    result += p->Coders[i].NumOutStreams;

-  return result;

-}

-

-int SzFolder_FindBindPairForInStream(CSzFolder *p, UInt32 inStreamIndex)

-{

-  UInt32 i;

-  for (i = 0; i < p->NumBindPairs; i++)

-    if (p->BindPairs[i].InIndex == inStreamIndex)

-      return i;

-  return -1;

-}

-

-

-int SzFolder_FindBindPairForOutStream(CSzFolder *p, UInt32 outStreamIndex)

-{

-  UInt32 i;

-  for (i = 0; i < p->NumBindPairs; i++)

-    if (p->BindPairs[i].OutIndex == outStreamIndex)

-      return i;

-  return -1;

-}

-

-UInt64 SzFolder_GetUnpackSize(CSzFolder *p)

-{

-  int i = (int)SzFolder_GetNumOutStreams(p);

-  if (i == 0)

-    return 0;

-  for (i--; i >= 0; i--)

-    if (SzFolder_FindBindPairForOutStream(p, i) < 0)

-      return p->UnpackSizes[i];

-  /* throw 1; */

-  return 0;

-}

-

-void SzFile_Init(CSzFileItem *p)

-{

-  p->HasStream = 1;

-  p->IsDir = 0;

-  p->IsAnti = 0;

-  p->CrcDefined = 0;

-  p->MTimeDefined = 0;

-}

-

-void SzAr_Init(CSzAr *p)

-{

-  p->PackSizes = 0;

-  p->PackCRCsDefined = 0;

-  p->PackCRCs = 0;

-  p->Folders = 0;

-  p->Files = 0;

-  p->NumPackStreams = 0;

-  p->NumFolders = 0;

-  p->NumFiles = 0;

-}

-

-void SzAr_Free(CSzAr *p, ISzAlloc *alloc)

-{

-  UInt32 i;

-  if (p->Folders)

-    for (i = 0; i < p->NumFolders; i++)

-      SzFolder_Free(&p->Folders[i], alloc);

-

-  IAlloc_Free(alloc, p->PackSizes);

-  IAlloc_Free(alloc, p->PackCRCsDefined);

-  IAlloc_Free(alloc, p->PackCRCs);

-  IAlloc_Free(alloc, p->Folders);

-  IAlloc_Free(alloc, p->Files);

-  SzAr_Init(p);

-}

-

-

-void SzArEx_Init(CSzArEx *p)

-{

-  SzAr_Init(&p->db);

-  p->FolderStartPackStreamIndex = 0;

-  p->PackStreamStartPositions = 0;

-  p->FolderStartFileIndex = 0;

-  p->FileIndexToFolderIndexMap = 0;

-  p->FileNameOffsets = 0;

-  Buf_Init(&p->FileNames);

-}

-

-void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc)

-{

-  IAlloc_Free(alloc, p->FolderStartPackStreamIndex);

-  IAlloc_Free(alloc, p->PackStreamStartPositions);

-  IAlloc_Free(alloc, p->FolderStartFileIndex);

-  IAlloc_Free(alloc, p->FileIndexToFolderIndexMap);

-

-  IAlloc_Free(alloc, p->FileNameOffsets);

-  Buf_Free(&p->FileNames, alloc);

-

-  SzAr_Free(&p->db, alloc);

-  SzArEx_Init(p);

-}

-

-/*

-UInt64 GetFolderPackStreamSize(int folderIndex, int streamIndex) const

-{

-  return PackSizes[FolderStartPackStreamIndex[folderIndex] + streamIndex];

-}

-

-UInt64 GetFilePackSize(int fileIndex) const

-{

-  int folderIndex = FileIndexToFolderIndexMap[fileIndex];

-  if (folderIndex >= 0)

-  {

-    const CSzFolder &folderInfo = Folders[folderIndex];

-    if (FolderStartFileIndex[folderIndex] == fileIndex)

-    return GetFolderFullPackSize(folderIndex);

-  }

-  return 0;

-}

-*/

-

-#define MY_ALLOC(T, p, size, alloc) { if ((size) == 0) p = 0; else \

-  if ((p = (T *)IAlloc_Alloc(alloc, (size) * sizeof(T))) == 0) return SZ_ERROR_MEM; }

-

-static SRes SzArEx_Fill(CSzArEx *p, ISzAlloc *alloc)

-{

-  UInt32 startPos = 0;

-  UInt64 startPosSize = 0;

-  UInt32 i;

-  UInt32 folderIndex = 0;

-  UInt32 indexInFolder = 0;

-  MY_ALLOC(UInt32, p->FolderStartPackStreamIndex, p->db.NumFolders, alloc);

-  for (i = 0; i < p->db.NumFolders; i++)

-  {

-    p->FolderStartPackStreamIndex[i] = startPos;

-    startPos += p->db.Folders[i].NumPackStreams;

-  }

-

-  MY_ALLOC(UInt64, p->PackStreamStartPositions, p->db.NumPackStreams, alloc);

-

-  for (i = 0; i < p->db.NumPackStreams; i++)

-  {

-    p->PackStreamStartPositions[i] = startPosSize;

-    startPosSize += p->db.PackSizes[i];

-  }

-

-  MY_ALLOC(UInt32, p->FolderStartFileIndex, p->db.NumFolders, alloc);

-  MY_ALLOC(UInt32, p->FileIndexToFolderIndexMap, p->db.NumFiles, alloc);

-

-  for (i = 0; i < p->db.NumFiles; i++)

-  {

-    CSzFileItem *file = p->db.Files + i;

-    int emptyStream = !file->HasStream;

-    if (emptyStream && indexInFolder == 0)

-    {

-      p->FileIndexToFolderIndexMap[i] = (UInt32)-1;

-      continue;

-    }

-    if (indexInFolder == 0)

-    {

-      /*

-      v3.13 incorrectly worked with empty folders

-      v4.07: Loop for skipping empty folders

-      */

-      for (;;)

-      {

-        if (folderIndex >= p->db.NumFolders)

-          return SZ_ERROR_ARCHIVE;

-        p->FolderStartFileIndex[folderIndex] = i;

-        if (p->db.Folders[folderIndex].NumUnpackStreams != 0)

-          break;

-        folderIndex++;

-      }

-    }

-    p->FileIndexToFolderIndexMap[i] = folderIndex;

-    if (emptyStream)

-      continue;

-    indexInFolder++;

-    if (indexInFolder >= p->db.Folders[folderIndex].NumUnpackStreams)

-    {

-      folderIndex++;

-      indexInFolder = 0;

-    }

-  }

-  return SZ_OK;

-}

-

-

-UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder)

-{

-  return p->dataPos +

-    p->PackStreamStartPositions[p->FolderStartPackStreamIndex[folderIndex] + indexInFolder];

-}

-

-int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize)

-{

-  UInt32 packStreamIndex = p->FolderStartPackStreamIndex[folderIndex];

-  CSzFolder *folder = p->db.Folders + folderIndex;

-  UInt64 size = 0;

-  UInt32 i;

-  for (i = 0; i < folder->NumPackStreams; i++)

-  {

-    UInt64 t = size + p->db.PackSizes[packStreamIndex + i];

-    if (t < size) /* check it */

-      return SZ_ERROR_FAIL;

-    size = t;

-  }

-  *resSize = size;

-  return SZ_OK;

-}

-

-

-/*

-SRes SzReadTime(const CObjectVector<CBuf> &dataVector,

-    CObjectVector<CSzFileItem> &files, UInt64 type)

-{

-  CBoolVector boolVector;

-  RINOK(ReadBoolVector2(files.Size(), boolVector))

-

-  CStreamSwitch streamSwitch;

-  RINOK(streamSwitch.Set(this, &dataVector));

-

-  for (int i = 0; i < files.Size(); i++)

-  {

-    CSzFileItem &file = files[i];

-    CArchiveFileTime fileTime;

-    bool defined = boolVector[i];

-    if (defined)

-    {

-      UInt32 low, high;

-      RINOK(SzReadUInt32(low));

-      RINOK(SzReadUInt32(high));

-      fileTime.dwLowDateTime = low;

-      fileTime.dwHighDateTime = high;

-    }

-    switch(type)

-    {

-      case k7zIdCTime: file.IsCTimeDefined = defined; if (defined) file.CTime = fileTime; break;

-      case k7zIdATime: file.IsATimeDefined = defined; if (defined) file.ATime = fileTime; break;

-      case k7zIdMTime: file.IsMTimeDefined = defined; if (defined) file.MTime = fileTime; break;

-    }

-  }

-  return SZ_OK;

-}

-*/

-

-static int TestSignatureCandidate(Byte *testBytes)

-{

-  size_t i;

-  for (i = 0; i < k7zSignatureSize; i++)

-    if (testBytes[i] != k7zSignature[i])

-      return 0;

-  return 1;

-}

-

-typedef struct _CSzState

-{

-  Byte *Data;

-  size_t Size;

-}CSzData;

-

-static SRes SzReadByte(CSzData *sd, Byte *b)

-{

-  if (sd->Size == 0)

-    return SZ_ERROR_ARCHIVE;

-  sd->Size--;

-  *b = *sd->Data++;

-  return SZ_OK;

-}

-

-static SRes SzReadBytes(CSzData *sd, Byte *data, size_t size)

-{

-  size_t i;

-  for (i = 0; i < size; i++)

-  {

-    RINOK(SzReadByte(sd, data + i));

-  }

-  return SZ_OK;

-}

-

-static SRes SzReadUInt32(CSzData *sd, UInt32 *value)

-{

-  int i;

-  *value = 0;

-  for (i = 0; i < 4; i++)

-  {

-    Byte b;

-    RINOK(SzReadByte(sd, &b));

-    *value |= ((UInt32)(b) << (8 * i));

-  }

-  return SZ_OK;

-}

-

-static SRes SzReadNumber(CSzData *sd, UInt64 *value)

-{

-  Byte firstByte;

-  Byte mask = 0x80;

-  int i;

-  RINOK(SzReadByte(sd, &firstByte));

-  *value = 0;

-  for (i = 0; i < 8; i++)

-  {

-    Byte b;

-    if ((firstByte & mask) == 0)

-    {

-      UInt64 highPart = firstByte & (mask - 1);

-      *value += (highPart << (8 * i));

-      return SZ_OK;

-    }

-    RINOK(SzReadByte(sd, &b));

-    *value |= ((UInt64)b << (8 * i));

-    mask >>= 1;

-  }

-  return SZ_OK;

-}

-

-static SRes SzReadNumber32(CSzData *sd, UInt32 *value)

-{

-  UInt64 value64;

-  RINOK(SzReadNumber(sd, &value64));

-  if (value64 >= 0x80000000)

-    return SZ_ERROR_UNSUPPORTED;

-  if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 2)))

-    return SZ_ERROR_UNSUPPORTED;

-  *value = (UInt32)value64;

-  return SZ_OK;

-}

-

-static SRes SzReadID(CSzData *sd, UInt64 *value)

-{

-  return SzReadNumber(sd, value);

-}

-

-static SRes SzSkeepDataSize(CSzData *sd, UInt64 size)

-{

-  if (size > sd->Size)

-    return SZ_ERROR_ARCHIVE;

-  sd->Size -= (size_t)size;

-  sd->Data += (size_t)size;

-  return SZ_OK;

-}

-

-static SRes SzSkeepData(CSzData *sd)

-{

-  UInt64 size;

-  RINOK(SzReadNumber(sd, &size));

-  return SzSkeepDataSize(sd, size);

-}

-

-static SRes SzReadArchiveProperties(CSzData *sd)

-{

-  for (;;)

-  {

-    UInt64 type;

-    RINOK(SzReadID(sd, &type));

-    if (type == k7zIdEnd)

-      break;

-    SzSkeepData(sd);

-  }

-  return SZ_OK;

-}

-

-static SRes SzWaitAttribute(CSzData *sd, UInt64 attribute)

-{

-  for (;;)

-  {

-    UInt64 type;

-    RINOK(SzReadID(sd, &type));

-    if (type == attribute)

-      return SZ_OK;

-    if (type == k7zIdEnd)

-      return SZ_ERROR_ARCHIVE;

-    RINOK(SzSkeepData(sd));

-  }

-}

-

-static SRes SzReadBoolVector(CSzData *sd, size_t numItems, Byte **v, ISzAlloc *alloc)

-{

-  Byte b = 0;

-  Byte mask = 0;

-  size_t i;

-  MY_ALLOC(Byte, *v, numItems, alloc);

-  for (i = 0; i < numItems; i++)

-  {

-    if (mask == 0)

-    {

-      RINOK(SzReadByte(sd, &b));

-      mask = 0x80;

-    }

-    (*v)[i] = (Byte)(((b & mask) != 0) ? 1 : 0);

-    mask >>= 1;

-  }

-  return SZ_OK;

-}

-

-static SRes SzReadBoolVector2(CSzData *sd, size_t numItems, Byte **v, ISzAlloc *alloc)

-{

-  Byte allAreDefined;

-  size_t i;

-  RINOK(SzReadByte(sd, &allAreDefined));

-  if (allAreDefined == 0)

-    return SzReadBoolVector(sd, numItems, v, alloc);

-  MY_ALLOC(Byte, *v, numItems, alloc);

-  for (i = 0; i < numItems; i++)

-    (*v)[i] = 1;

-  return SZ_OK;

-}

-

-static SRes SzReadHashDigests(

-    CSzData *sd,

-    size_t numItems,

-    Byte **digestsDefined,

-    UInt32 **digests,

-    ISzAlloc *alloc)

-{

-  size_t i;

-  RINOK(SzReadBoolVector2(sd, numItems, digestsDefined, alloc));

-  MY_ALLOC(UInt32, *digests, numItems, alloc);

-  for (i = 0; i < numItems; i++)

-    if ((*digestsDefined)[i])

-    {

-      RINOK(SzReadUInt32(sd, (*digests) + i));

-    }

-  return SZ_OK;

-}

-

-static SRes SzReadPackInfo(

-    CSzData *sd,

-    UInt64 *dataOffset,

-    UInt32 *numPackStreams,

-    UInt64 **packSizes,

-    Byte **packCRCsDefined,

-    UInt32 **packCRCs,

-    ISzAlloc *alloc)

-{

-  UInt32 i;

-  RINOK(SzReadNumber(sd, dataOffset));

-  RINOK(SzReadNumber32(sd, numPackStreams));

-

-  RINOK(SzWaitAttribute(sd, k7zIdSize));

-

-  MY_ALLOC(UInt64, *packSizes, (size_t)*numPackStreams, alloc);

-

-  for (i = 0; i < *numPackStreams; i++)

-  {

-    RINOK(SzReadNumber(sd, (*packSizes) + i));

-  }

-

-  for (;;)

-  {

-    UInt64 type;

-    RINOK(SzReadID(sd, &type));

-    if (type == k7zIdEnd)

-      break;

-    if (type == k7zIdCRC)

-    {

-      RINOK(SzReadHashDigests(sd, (size_t)*numPackStreams, packCRCsDefined, packCRCs, alloc));

-      continue;

-    }

-    RINOK(SzSkeepData(sd));

-  }

-  if (*packCRCsDefined == 0)

-  {

-    MY_ALLOC(Byte, *packCRCsDefined, (size_t)*numPackStreams, alloc);

-    MY_ALLOC(UInt32, *packCRCs, (size_t)*numPackStreams, alloc);

-    for (i = 0; i < *numPackStreams; i++)

-    {

-      (*packCRCsDefined)[i] = 0;

-      (*packCRCs)[i] = 0;

-    }

-  }

-  return SZ_OK;

-}

-

-static SRes SzReadSwitch(CSzData *sd)

-{

-  Byte external;

-  RINOK(SzReadByte(sd, &external));

-  return (external == 0) ? SZ_OK: SZ_ERROR_UNSUPPORTED;

-}

-

-static SRes SzGetNextFolderItem(CSzData *sd, CSzFolder *folder, ISzAlloc *alloc)

-{

-  UInt32 numCoders, numBindPairs, numPackStreams, i;

-  UInt32 numInStreams = 0, numOutStreams = 0;

-  

-  RINOK(SzReadNumber32(sd, &numCoders));

-  if (numCoders > NUM_FOLDER_CODERS_MAX)

-    return SZ_ERROR_UNSUPPORTED;

-  folder->NumCoders = numCoders;

-  

-  MY_ALLOC(CSzCoderInfo, folder->Coders, (size_t)numCoders, alloc);

-

-  for (i = 0; i < numCoders; i++)

-    SzCoderInfo_Init(folder->Coders + i);

-

-  for (i = 0; i < numCoders; i++)

-  {

-    Byte mainByte;

-    CSzCoderInfo *coder = folder->Coders + i;

-    {

-      unsigned idSize, j;

-      Byte longID[15];

-      RINOK(SzReadByte(sd, &mainByte));

-      idSize = (unsigned)(mainByte & 0xF);

-      RINOK(SzReadBytes(sd, longID, idSize));

-      if (idSize > sizeof(coder->MethodID))

-        return SZ_ERROR_UNSUPPORTED;

-      coder->MethodID = 0;

-      for (j = 0; j < idSize; j++)

-        coder->MethodID |= (UInt64)longID[idSize - 1 - j] << (8 * j);

-

-      if ((mainByte & 0x10) != 0)

-      {

-        RINOK(SzReadNumber32(sd, &coder->NumInStreams));

-        RINOK(SzReadNumber32(sd, &coder->NumOutStreams));

-        if (coder->NumInStreams > NUM_CODER_STREAMS_MAX ||

-            coder->NumOutStreams > NUM_CODER_STREAMS_MAX)

-          return SZ_ERROR_UNSUPPORTED;

-      }

-      else

-      {

-        coder->NumInStreams = 1;

-        coder->NumOutStreams = 1;

-      }

-      if ((mainByte & 0x20) != 0)

-      {

-        UInt64 propertiesSize = 0;

-        RINOK(SzReadNumber(sd, &propertiesSize));

-        if (!Buf_Create(&coder->Props, (size_t)propertiesSize, alloc))

-          return SZ_ERROR_MEM;

-        RINOK(SzReadBytes(sd, coder->Props.data, (size_t)propertiesSize));

-      }

-    }

-    while ((mainByte & 0x80) != 0)

-    {

-      RINOK(SzReadByte(sd, &mainByte));

-      RINOK(SzSkeepDataSize(sd, (mainByte & 0xF)));

-      if ((mainByte & 0x10) != 0)

-      {

-        UInt32 n;

-        RINOK(SzReadNumber32(sd, &n));

-        RINOK(SzReadNumber32(sd, &n));

-      }

-      if ((mainByte & 0x20) != 0)

-      {

-        UInt64 propertiesSize = 0;

-        RINOK(SzReadNumber(sd, &propertiesSize));

-        RINOK(SzSkeepDataSize(sd, propertiesSize));

-      }

-    }

-    numInStreams += coder->NumInStreams;

-    numOutStreams += coder->NumOutStreams;

-  }

-

-  if (numOutStreams == 0)

-    return SZ_ERROR_UNSUPPORTED;

-

-  folder->NumBindPairs = numBindPairs = numOutStreams - 1;

-  MY_ALLOC(CSzBindPair, folder->BindPairs, (size_t)numBindPairs, alloc);

-

-  for (i = 0; i < numBindPairs; i++)

-  {

-    CSzBindPair *bp = folder->BindPairs + i;

-    RINOK(SzReadNumber32(sd, &bp->InIndex));

-    RINOK(SzReadNumber32(sd, &bp->OutIndex));

-  }

-

-  if (numInStreams < numBindPairs)

-    return SZ_ERROR_UNSUPPORTED;

-

-  folder->NumPackStreams = numPackStreams = numInStreams - numBindPairs;

-  MY_ALLOC(UInt32, folder->PackStreams, (size_t)numPackStreams, alloc);

-

-  if (numPackStreams == 1)

-  {

-    for (i = 0; i < numInStreams ; i++)

-      if (SzFolder_FindBindPairForInStream(folder, i) < 0)

-        break;

-    if (i == numInStreams)

-      return SZ_ERROR_UNSUPPORTED;

-    folder->PackStreams[0] = i;

-  }

-  else

-    for (i = 0; i < numPackStreams; i++)

-    {

-      RINOK(SzReadNumber32(sd, folder->PackStreams + i));

-    }

-  return SZ_OK;

-}

-

-static SRes SzReadUnpackInfo(

-    CSzData *sd,

-    UInt32 *numFolders,

-    CSzFolder **folders,  /* for alloc */

-    ISzAlloc *alloc,

-    ISzAlloc *allocTemp)

-{

-  UInt32 i;

-  RINOK(SzWaitAttribute(sd, k7zIdFolder));

-  RINOK(SzReadNumber32(sd, numFolders));

-  {

-    RINOK(SzReadSwitch(sd));

-

-    MY_ALLOC(CSzFolder, *folders, (size_t)*numFolders, alloc);

-

-    for (i = 0; i < *numFolders; i++)

-      SzFolder_Init((*folders) + i);

-

-    for (i = 0; i < *numFolders; i++)

-    {

-      RINOK(SzGetNextFolderItem(sd, (*folders) + i, alloc));

-    }

-  }

-

-  RINOK(SzWaitAttribute(sd, k7zIdCodersUnpackSize));

-

-  for (i = 0; i < *numFolders; i++)

-  {

-    UInt32 j;

-    CSzFolder *folder = (*folders) + i;

-    UInt32 numOutStreams = SzFolder_GetNumOutStreams(folder);

-

-    MY_ALLOC(UInt64, folder->UnpackSizes, (size_t)numOutStreams, alloc);

-

-    for (j = 0; j < numOutStreams; j++)

-    {

-      RINOK(SzReadNumber(sd, folder->UnpackSizes + j));

-    }

-  }

-

-  for (;;)

-  {

-    UInt64 type;

-    RINOK(SzReadID(sd, &type));

-    if (type == k7zIdEnd)

-      return SZ_OK;

-    if (type == k7zIdCRC)

-    {

-      SRes res;

-      Byte *crcsDefined = 0;

-      UInt32 *crcs = 0;

-      res = SzReadHashDigests(sd, *numFolders, &crcsDefined, &crcs, allocTemp);

-      if (res == SZ_OK)

-      {

-        for (i = 0; i < *numFolders; i++)

-        {

-          CSzFolder *folder = (*folders) + i;

-          folder->UnpackCRCDefined = crcsDefined[i];

-          folder->UnpackCRC = crcs[i];

-        }

-      }

-      IAlloc_Free(allocTemp, crcs);

-      IAlloc_Free(allocTemp, crcsDefined);

-      RINOK(res);

-      continue;

-    }

-    RINOK(SzSkeepData(sd));

-  }

-}

-

-static SRes SzReadSubStreamsInfo(

-    CSzData *sd,

-    UInt32 numFolders,

-    CSzFolder *folders,

-    UInt32 *numUnpackStreams,

-    UInt64 **unpackSizes,

-    Byte **digestsDefined,

-    UInt32 **digests,

-    ISzAlloc *allocTemp)

-{

-  UInt64 type = 0;

-  UInt32 i;

-  UInt32 si = 0;

-  UInt32 numDigests = 0;

-

-  for (i = 0; i < numFolders; i++)

-    folders[i].NumUnpackStreams = 1;

-  *numUnpackStreams = numFolders;

-

-  for (;;)

-  {

-    RINOK(SzReadID(sd, &type));

-    if (type == k7zIdNumUnpackStream)

-    {

-      *numUnpackStreams = 0;

-      for (i = 0; i < numFolders; i++)

-      {

-        UInt32 numStreams;

-        RINOK(SzReadNumber32(sd, &numStreams));

-        folders[i].NumUnpackStreams = numStreams;

-        *numUnpackStreams += numStreams;

-      }

-      continue;

-    }

-    if (type == k7zIdCRC || type == k7zIdSize)

-      break;

-    if (type == k7zIdEnd)

-      break;

-    RINOK(SzSkeepData(sd));

-  }

-

-  if (*numUnpackStreams == 0)

-  {

-    *unpackSizes = 0;

-    *digestsDefined = 0;

-    *digests = 0;

-  }

-  else

-  {

-    *unpackSizes = (UInt64 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt64));

-    RINOM(*unpackSizes);

-    *digestsDefined = (Byte *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(Byte));

-    RINOM(*digestsDefined);

-    *digests = (UInt32 *)IAlloc_Alloc(allocTemp, (size_t)*numUnpackStreams * sizeof(UInt32));

-    RINOM(*digests);

-  }

-

-  for (i = 0; i < numFolders; i++)

-  {

-    /*

-    v3.13 incorrectly worked with empty folders

-    v4.07: we check that folder is empty

-    */

-    UInt64 sum = 0;

-    UInt32 j;

-    UInt32 numSubstreams = folders[i].NumUnpackStreams;

-    if (numSubstreams == 0)

-      continue;

-    if (type == k7zIdSize)

-    for (j = 1; j < numSubstreams; j++)

-    {

-      UInt64 size;

-      RINOK(SzReadNumber(sd, &size));

-      (*unpackSizes)[si++] = size;

-      sum += size;

-    }

-    (*unpackSizes)[si++] = SzFolder_GetUnpackSize(folders + i) - sum;

-  }

-  if (type == k7zIdSize)

-  {

-    RINOK(SzReadID(sd, &type));

-  }

-

-  for (i = 0; i < *numUnpackStreams; i++)

-  {

-    (*digestsDefined)[i] = 0;

-    (*digests)[i] = 0;

-  }

-

-

-  for (i = 0; i < numFolders; i++)

-  {

-    UInt32 numSubstreams = folders[i].NumUnpackStreams;

-    if (numSubstreams != 1 || !folders[i].UnpackCRCDefined)

-      numDigests += numSubstreams;

-  }

-

- 

-  si = 0;

-  for (;;)

-  {

-    if (type == k7zIdCRC)

-    {

-      int digestIndex = 0;

-      Byte *digestsDefined2 = 0;

-      UInt32 *digests2 = 0;

-      SRes res = SzReadHashDigests(sd, numDigests, &digestsDefined2, &digests2, allocTemp);

-      if (res == SZ_OK)

-      {

-        for (i = 0; i < numFolders; i++)

-        {

-          CSzFolder *folder = folders + i;

-          UInt32 numSubstreams = folder->NumUnpackStreams;

-          if (numSubstreams == 1 && folder->UnpackCRCDefined)

-          {

-            (*digestsDefined)[si] = 1;

-            (*digests)[si] = folder->UnpackCRC;

-            si++;

-          }

-          else

-          {

-            UInt32 j;

-            for (j = 0; j < numSubstreams; j++, digestIndex++)

-            {

-              (*digestsDefined)[si] = digestsDefined2[digestIndex];

-              (*digests)[si] = digests2[digestIndex];

-              si++;

-            }

-          }

-        }

-      }

-      IAlloc_Free(allocTemp, digestsDefined2);

-      IAlloc_Free(allocTemp, digests2);

-      RINOK(res);

-    }

-    else if (type == k7zIdEnd)

-      return SZ_OK;

-    else

-    {

-      RINOK(SzSkeepData(sd));

-    }

-    RINOK(SzReadID(sd, &type));

-  }

-}

-

-

-static SRes SzReadStreamsInfo(

-    CSzData *sd,

-    UInt64 *dataOffset,

-    CSzAr *p,

-    UInt32 *numUnpackStreams,

-    UInt64 **unpackSizes, /* allocTemp */

-    Byte **digestsDefined,   /* allocTemp */

-    UInt32 **digests,        /* allocTemp */

-    ISzAlloc *alloc,

-    ISzAlloc *allocTemp)

-{

-  for (;;)

-  {

-    UInt64 type;

-    RINOK(SzReadID(sd, &type));

-    if ((UInt64)(int)type != type)

-      return SZ_ERROR_UNSUPPORTED;

-    switch((int)type)

-    {

-      case k7zIdEnd:

-        return SZ_OK;

-      case k7zIdPackInfo:

-      {

-        RINOK(SzReadPackInfo(sd, dataOffset, &p->NumPackStreams,

-            &p->PackSizes, &p->PackCRCsDefined, &p->PackCRCs, alloc));

-        break;

-      }

-      case k7zIdUnpackInfo:

-      {

-        RINOK(SzReadUnpackInfo(sd, &p->NumFolders, &p->Folders, alloc, allocTemp));

-        break;

-      }

-      case k7zIdSubStreamsInfo:

-      {

-        RINOK(SzReadSubStreamsInfo(sd, p->NumFolders, p->Folders,

-            numUnpackStreams, unpackSizes, digestsDefined, digests, allocTemp));

-        break;

-      }

-      default:

-        return SZ_ERROR_UNSUPPORTED;

-    }

-  }

-}

-

-size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)

-{

-  size_t len = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];

-  if (dest != 0)

-  {

-    size_t i;

-    const Byte *src = p->FileNames.data + (p->FileNameOffsets[fileIndex] * 2);

-    for (i = 0; i < len; i++)

-      dest[i] = GetUi16(src + i * 2);

-  }

-  return len;

-}

-

-static SRes SzReadFileNames(const Byte *p, size_t size, UInt32 numFiles, size_t *sizes)

-{

-  UInt32 i;

-  size_t pos = 0;

-  for (i = 0; i < numFiles; i++)

-  {

-    sizes[i] = pos;

-    for (;;)

-    {

-      if (pos >= size)

-        return SZ_ERROR_ARCHIVE;

-      if (p[pos * 2] == 0 && p[pos * 2 + 1] == 0)

-        break;

-      pos++;

-    }

-    pos++;

-  }

-  sizes[i] = pos;

-  return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;

-}

-

-static SRes SzReadHeader2(

-    CSzArEx *p,   /* allocMain */

-    CSzData *sd,

-    UInt64 **unpackSizes,  /* allocTemp */

-    Byte **digestsDefined,    /* allocTemp */

-    UInt32 **digests,         /* allocTemp */

-    Byte **emptyStreamVector, /* allocTemp */

-    Byte **emptyFileVector,   /* allocTemp */

-    Byte **lwtVector,         /* allocTemp */

-    ISzAlloc *allocMain,

-    ISzAlloc *allocTemp)

-{

-  UInt64 type;

-  UInt32 numUnpackStreams = 0;

-  UInt32 numFiles = 0;

-  CSzFileItem *files = 0;

-  UInt32 numEmptyStreams = 0;

-  UInt32 i;

-

-  RINOK(SzReadID(sd, &type));

-

-  if (type == k7zIdArchiveProperties)

-  {

-    RINOK(SzReadArchiveProperties(sd));

-    RINOK(SzReadID(sd, &type));

-  }

- 

- 

-  if (type == k7zIdMainStreamsInfo)

-  {

-    RINOK(SzReadStreamsInfo(sd,

-        &p->dataPos,

-        &p->db,

-        &numUnpackStreams,

-        unpackSizes,

-        digestsDefined,

-        digests, allocMain, allocTemp));

-    p->dataPos += p->startPosAfterHeader;

-    RINOK(SzReadID(sd, &type));

-  }

-

-  if (type == k7zIdEnd)

-    return SZ_OK;

-  if (type != k7zIdFilesInfo)

-    return SZ_ERROR_ARCHIVE;

-  

-  RINOK(SzReadNumber32(sd, &numFiles));

-  p->db.NumFiles = numFiles;

-

-  MY_ALLOC(CSzFileItem, files, (size_t)numFiles, allocMain);

-

-  p->db.Files = files;

-  for (i = 0; i < numFiles; i++)

-    SzFile_Init(files + i);

-

-  for (;;)

-  {

-    UInt64 type;

-    UInt64 size;

-    RINOK(SzReadID(sd, &type));

-    if (type == k7zIdEnd)

-      break;

-    RINOK(SzReadNumber(sd, &size));

-    if (size > sd->Size)

-      return SZ_ERROR_ARCHIVE;

-    if ((UInt64)(int)type != type)

-    {

-      RINOK(SzSkeepDataSize(sd, size));

-    }

-    else

-    switch((int)type)

-    {

-      case k7zIdName:

-      {

-        size_t namesSize;

-        RINOK(SzReadSwitch(sd));

-        namesSize = (size_t)size - 1;

-        if ((namesSize & 1) != 0)

-          return SZ_ERROR_ARCHIVE;

-        if (!Buf_Create(&p->FileNames, namesSize, allocMain))

-          return SZ_ERROR_MEM;

-        MY_ALLOC(size_t, p->FileNameOffsets, numFiles + 1, allocMain);

-        memcpy(p->FileNames.data, sd->Data, namesSize);

-        RINOK(SzReadFileNames(sd->Data, namesSize >> 1, numFiles, p->FileNameOffsets))

-        RINOK(SzSkeepDataSize(sd, namesSize));

-        break;

-      }

-      case k7zIdEmptyStream:

-      {

-        RINOK(SzReadBoolVector(sd, numFiles, emptyStreamVector, allocTemp));

-        numEmptyStreams = 0;

-        for (i = 0; i < numFiles; i++)

-          if ((*emptyStreamVector)[i])

-            numEmptyStreams++;

-        break;

-      }

-      case k7zIdEmptyFile:

-      {

-        RINOK(SzReadBoolVector(sd, numEmptyStreams, emptyFileVector, allocTemp));

-        break;

-      }

-      case k7zIdWinAttributes:

-      {

-        RINOK(SzReadBoolVector2(sd, numFiles, lwtVector, allocTemp));

-        RINOK(SzReadSwitch(sd));

-        for (i = 0; i < numFiles; i++)

-        {

-          CSzFileItem *f = &files[i];

-          Byte defined = (*lwtVector)[i];

-          f->AttribDefined = defined;

-          f->Attrib = 0;

-          if (defined)

-          {

-            RINOK(SzReadUInt32(sd, &f->Attrib));

-          }

-        }

-        IAlloc_Free(allocTemp, *lwtVector);

-        *lwtVector = NULL;

-        break;

-      }

-      case k7zIdMTime:

-      {

-        RINOK(SzReadBoolVector2(sd, numFiles, lwtVector, allocTemp));

-        RINOK(SzReadSwitch(sd));

-        for (i = 0; i < numFiles; i++)

-        {

-          CSzFileItem *f = &files[i];

-          Byte defined = (*lwtVector)[i];

-          f->MTimeDefined = defined;

-          f->MTime.Low = f->MTime.High = 0;

-          if (defined)

-          {

-            RINOK(SzReadUInt32(sd, &f->MTime.Low));

-            RINOK(SzReadUInt32(sd, &f->MTime.High));

-          }

-        }

-        IAlloc_Free(allocTemp, *lwtVector);

-        *lwtVector = NULL;

-        break;

-      }

-      default:

-      {

-        RINOK(SzSkeepDataSize(sd, size));

-      }

-    }

-  }

-

-  {

-    UInt32 emptyFileIndex = 0;

-    UInt32 sizeIndex = 0;

-    for (i = 0; i < numFiles; i++)

-    {

-      CSzFileItem *file = files + i;

-      file->IsAnti = 0;

-      if (*emptyStreamVector == 0)

-        file->HasStream = 1;

-      else

-        file->HasStream = (Byte)((*emptyStreamVector)[i] ? 0 : 1);

-      if (file->HasStream)

-      {

-        file->IsDir = 0;

-        file->Size = (*unpackSizes)[sizeIndex];

-        file->Crc = (*digests)[sizeIndex];

-        file->CrcDefined = (Byte)(*digestsDefined)[sizeIndex];

-        sizeIndex++;

-      }

-      else

-      {

-        if (*emptyFileVector == 0)

-          file->IsDir = 1;

-        else

-          file->IsDir = (Byte)((*emptyFileVector)[emptyFileIndex] ? 0 : 1);

-        emptyFileIndex++;

-        file->Size = 0;

-        file->Crc = 0;

-        file->CrcDefined = 0;

-      }

-    }

-  }

-  return SzArEx_Fill(p, allocMain);

-}

-

-static SRes SzReadHeader(

-    CSzArEx *p,

-    CSzData *sd,

-    ISzAlloc *allocMain,

-    ISzAlloc *allocTemp)

-{

-  UInt64 *unpackSizes = 0;

-  Byte *digestsDefined = 0;

-  UInt32 *digests = 0;

-  Byte *emptyStreamVector = 0;

-  Byte *emptyFileVector = 0;

-  Byte *lwtVector = 0;

-  SRes res = SzReadHeader2(p, sd,

-      &unpackSizes, &digestsDefined, &digests,

-      &emptyStreamVector, &emptyFileVector, &lwtVector,

-      allocMain, allocTemp);

-  IAlloc_Free(allocTemp, unpackSizes);

-  IAlloc_Free(allocTemp, digestsDefined);

-  IAlloc_Free(allocTemp, digests);

-  IAlloc_Free(allocTemp, emptyStreamVector);

-  IAlloc_Free(allocTemp, emptyFileVector);

-  IAlloc_Free(allocTemp, lwtVector);

-  return res;

-}

-

-static SRes SzReadAndDecodePackedStreams2(

-    ILookInStream *inStream,

-    CSzData *sd,

-    CBuf *outBuffer,

-    UInt64 baseOffset,

-    CSzAr *p,

-    UInt64 **unpackSizes,

-    Byte **digestsDefined,

-    UInt32 **digests,

-    ISzAlloc *allocTemp)

-{

-

-  UInt32 numUnpackStreams = 0;

-  UInt64 dataStartPos;

-  CSzFolder *folder;

-  UInt64 unpackSize;

-  SRes res;

-

-  RINOK(SzReadStreamsInfo(sd, &dataStartPos, p,

-      &numUnpackStreams,  unpackSizes, digestsDefined, digests,

-      allocTemp, allocTemp));

-  

-  dataStartPos += baseOffset;

-  if (p->NumFolders != 1)

-    return SZ_ERROR_ARCHIVE;

-

-  folder = p->Folders;

-  unpackSize = SzFolder_GetUnpackSize(folder);

-  

-  RINOK(LookInStream_SeekTo(inStream, dataStartPos));

-

-  if (!Buf_Create(outBuffer, (size_t)unpackSize, allocTemp))

-    return SZ_ERROR_MEM;

-  

-  res = SzFolder_Decode(folder, p->PackSizes,

-          inStream, dataStartPos,

-          outBuffer->data, (size_t)unpackSize, allocTemp);

-  RINOK(res);

-  if (folder->UnpackCRCDefined)

-    if (CrcCalc(outBuffer->data, (size_t)unpackSize) != folder->UnpackCRC)

-      return SZ_ERROR_CRC;

-  return SZ_OK;

-}

-

-static SRes SzReadAndDecodePackedStreams(

-    ILookInStream *inStream,

-    CSzData *sd,

-    CBuf *outBuffer,

-    UInt64 baseOffset,

-    ISzAlloc *allocTemp)

-{

-  CSzAr p;

-  UInt64 *unpackSizes = 0;

-  Byte *digestsDefined = 0;

-  UInt32 *digests = 0;

-  SRes res;

-  SzAr_Init(&p);

-  res = SzReadAndDecodePackedStreams2(inStream, sd, outBuffer, baseOffset,

-    &p, &unpackSizes, &digestsDefined, &digests,

-    allocTemp);

-  SzAr_Free(&p, allocTemp);

-  IAlloc_Free(allocTemp, unpackSizes);

-  IAlloc_Free(allocTemp, digestsDefined);

-  IAlloc_Free(allocTemp, digests);

-  return res;

-}

-

-static SRes SzArEx_Open2(

-    CSzArEx *p,

-    ILookInStream *inStream,

-    ISzAlloc *allocMain,

-    ISzAlloc *allocTemp)

-{

-  Byte header[k7zStartHeaderSize];

-  Int64 startArcPos;

-  UInt64 nextHeaderOffset, nextHeaderSize;

-  size_t nextHeaderSizeT;

-  UInt32 nextHeaderCRC;

-  CBuf buffer;

-  SRes res;

-

-  startArcPos = 0;

-  RINOK(inStream->Seek(inStream, &startArcPos, SZ_SEEK_CUR));

-

-  RINOK(LookInStream_Read2(inStream, header, k7zStartHeaderSize, SZ_ERROR_NO_ARCHIVE));

-

-  if (!TestSignatureCandidate(header))

-    return SZ_ERROR_NO_ARCHIVE;

-  if (header[6] != k7zMajorVersion)

-    return SZ_ERROR_UNSUPPORTED;

-

-  nextHeaderOffset = GetUi64(header + 12);

-  nextHeaderSize = GetUi64(header + 20);

-  nextHeaderCRC = GetUi32(header + 28);

-

-  p->startPosAfterHeader = startArcPos + k7zStartHeaderSize;

-  

-  if (CrcCalc(header + 12, 20) != GetUi32(header + 8))

-    return SZ_ERROR_CRC;

-

-  nextHeaderSizeT = (size_t)nextHeaderSize;

-  if (nextHeaderSizeT != nextHeaderSize)

-    return SZ_ERROR_MEM;

-  if (nextHeaderSizeT == 0)

-    return SZ_OK;

-  if (nextHeaderOffset > nextHeaderOffset + nextHeaderSize ||

-      nextHeaderOffset > nextHeaderOffset + nextHeaderSize + k7zStartHeaderSize)

-    return SZ_ERROR_NO_ARCHIVE;

-

-  {

-    Int64 pos = 0;

-    RINOK(inStream->Seek(inStream, &pos, SZ_SEEK_END));

-    if ((UInt64)pos < startArcPos + nextHeaderOffset ||

-        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||

-        (UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)

-      return SZ_ERROR_INPUT_EOF;

-  }

-

-  RINOK(LookInStream_SeekTo(inStream, startArcPos + k7zStartHeaderSize + nextHeaderOffset));

-

-  if (!Buf_Create(&buffer, nextHeaderSizeT, allocTemp))

-    return SZ_ERROR_MEM;

-

-  res = LookInStream_Read(inStream, buffer.data, nextHeaderSizeT);

-  if (res == SZ_OK)

-  {

-    res = SZ_ERROR_ARCHIVE;

-    if (CrcCalc(buffer.data, nextHeaderSizeT) == nextHeaderCRC)

-    {

-      CSzData sd;

-      UInt64 type;

-      sd.Data = buffer.data;

-      sd.Size = buffer.size;

-      res = SzReadID(&sd, &type);

-      if (res == SZ_OK)

-      {

-        if (type == k7zIdEncodedHeader)

-        {

-          CBuf outBuffer;

-          Buf_Init(&outBuffer);

-          res = SzReadAndDecodePackedStreams(inStream, &sd, &outBuffer, p->startPosAfterHeader, allocTemp);

-          if (res != SZ_OK)

-            Buf_Free(&outBuffer, allocTemp);

-          else

-          {

-            Buf_Free(&buffer, allocTemp);

-            buffer.data = outBuffer.data;

-            buffer.size = outBuffer.size;

-            sd.Data = buffer.data;

-            sd.Size = buffer.size;

-            res = SzReadID(&sd, &type);

-          }

-        }

-      }

-      if (res == SZ_OK)

-      {

-        if (type == k7zIdHeader)

-          res = SzReadHeader(p, &sd, allocMain, allocTemp);

-        else

-          res = SZ_ERROR_UNSUPPORTED;

-      }

-    }

-  }

-  Buf_Free(&buffer, allocTemp);

-  return res;

-}

-

-SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp)

-{

-  SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);

-  if (res != SZ_OK)

-    SzArEx_Free(p, allocMain);

-  return res;

-}

-

-SRes SzArEx_Extract(

-    const CSzArEx *p,

-    ILookInStream *inStream,

-    UInt32 fileIndex,

-    UInt32 *blockIndex,

-    Byte **outBuffer,

-    size_t *outBufferSize,

-    size_t *offset,

-    size_t *outSizeProcessed,

-    ISzAlloc *allocMain,

-    ISzAlloc *allocTemp)

-{

-  UInt32 folderIndex = p->FileIndexToFolderIndexMap[fileIndex];

-  SRes res = SZ_OK;

-  *offset = 0;

-  *outSizeProcessed = 0;

-  if (folderIndex == (UInt32)-1)

-  {

-    IAlloc_Free(allocMain, *outBuffer);

-    *blockIndex = folderIndex;

-    *outBuffer = 0;

-    *outBufferSize = 0;

-    return SZ_OK;

-  }

-

-  if (*outBuffer == 0 || *blockIndex != folderIndex)

-  {

-    CSzFolder *folder = p->db.Folders + folderIndex;

-    UInt64 unpackSizeSpec = SzFolder_GetUnpackSize(folder);

-    size_t unpackSize = (size_t)unpackSizeSpec;

-    UInt64 startOffset = SzArEx_GetFolderStreamPos(p, folderIndex, 0);

-

-    if (unpackSize != unpackSizeSpec)

-      return SZ_ERROR_MEM;

-    *blockIndex = folderIndex;

-    IAlloc_Free(allocMain, *outBuffer);

-    *outBuffer = 0;

-    

-    RINOK(LookInStream_SeekTo(inStream, startOffset));

-    

-    if (res == SZ_OK)

-    {

-      *outBufferSize = unpackSize;

-      if (unpackSize != 0)

-      {

-        *outBuffer = (Byte *)IAlloc_Alloc(allocMain, unpackSize);

-        if (*outBuffer == 0)

-          res = SZ_ERROR_MEM;

-      }

-      if (res == SZ_OK)

-      {

-        res = SzFolder_Decode(folder,

-          p->db.PackSizes + p->FolderStartPackStreamIndex[folderIndex],

-          inStream, startOffset,

-          *outBuffer, unpackSize, allocTemp);

-        if (res == SZ_OK)

-        {

-          if (folder->UnpackCRCDefined)

-          {

-            if (CrcCalc(*outBuffer, unpackSize) != folder->UnpackCRC)

-              res = SZ_ERROR_CRC;

-          }

-        }

-      }

-    }

-  }

-  if (res == SZ_OK)

-  {

-    UInt32 i;

-    CSzFileItem *fileItem = p->db.Files + fileIndex;

-    *offset = 0;

-    for (i = p->FolderStartFileIndex[folderIndex]; i < fileIndex; i++)

-      *offset += (UInt32)p->db.Files[i].Size;

-    *outSizeProcessed = (size_t)fileItem->Size;

-    if (*offset + *outSizeProcessed > *outBufferSize)

-      return SZ_ERROR_FAIL;

-    if (fileItem->CrcDefined && CrcCalc(*outBuffer + *offset, *outSizeProcessed) != fileItem->Crc)

-      res = SZ_ERROR_CRC;

-  }

-  return res;

-}

diff --git a/C/7zStream.c b/C/7zStream.c
index f0959fb..5a92d53 100755..100644
--- a/C/7zStream.c
+++ b/C/7zStream.c
@@ -1,9 +1,11 @@
 /* 7zStream.c -- 7z Stream functions

-2010-03-11 : Igor Pavlov : Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include <string.h>

 

-#include "Types.h"

+#include "7zTypes.h"

 

 SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType)

 {

diff --git a/C/Types.h b/C/7zTypes.h
index f193ce2..903047b 100755..100644
--- a/C/Types.h
+++ b/C/7zTypes.h
@@ -1,15 +1,15 @@
-/* Types.h -- Basic types

-2010-10-09 : Igor Pavlov : Public domain */

+/* 7zTypes.h -- Basic types

+2013-11-12 : Igor Pavlov : Public domain */

 

 #ifndef __7Z_TYPES_H

 #define __7Z_TYPES_H

 

-#include <stddef.h>

-

 #ifdef _WIN32

-#include <windows.h>

+/* #include <windows.h> */

 #endif

 

+#include <stddef.h>

+

 #ifndef EXTERN_C_BEGIN

 #ifdef __cplusplus

 #define EXTERN_C_BEGIN extern "C" {

@@ -43,7 +43,8 @@ EXTERN_C_BEGIN
 typedef int SRes;

 

 #ifdef _WIN32

-typedef DWORD WRes;

+/* typedef DWORD WRes; */

+typedef unsigned WRes;

 #else

 typedef int WRes;

 #endif

@@ -116,6 +117,7 @@ typedef int Bool;
 

 #else

 

+#define MY_NO_INLINE

 #define MY_CDECL

 #define MY_FAST_CALL

 

diff --git a/C/7zVersion.h b/C/7zVersion.h
index d4ac470..feedd30 100755..100644
--- a/C/7zVersion.h
+++ b/C/7zVersion.h
@@ -1,7 +1,10 @@
 #define MY_VER_MAJOR 9

-#define MY_VER_MINOR 20

-#define MY_VER_BUILD 0

-#define MY_VERSION "9.20"

-#define MY_DATE "2010-11-18"

+#define MY_VER_MINOR 38

+#define MY_VER_BUILD 00

+#define MY_VERSION "9.38 beta"

+// #define MY_7ZIP_VERSION "9.38"

+#define MY_DATE "2015-01-03"

+#undef MY_COPYRIGHT

+#undef MY_VERSION_COPYRIGHT_DATE

 #define MY_COPYRIGHT ": Igor Pavlov : Public domain"

 #define MY_VERSION_COPYRIGHT_DATE MY_VERSION " " MY_COPYRIGHT " : " MY_DATE

diff --git a/C/7zVersion.rc b/C/7zVersion.rc
new file mode 100644
index 0000000..6ed26de
--- /dev/null
+++ b/C/7zVersion.rc
@@ -0,0 +1,55 @@
+#define MY_VS_FFI_FILEFLAGSMASK  0x0000003FL

+#define MY_VOS_NT_WINDOWS32  0x00040004L

+#define MY_VOS_CE_WINDOWS32  0x00050004L

+

+#define MY_VFT_APP  0x00000001L

+#define MY_VFT_DLL  0x00000002L

+

+// #include <WinVer.h>

+

+#ifndef MY_VERSION

+#include "7zVersion.h"

+#endif

+

+#define MY_VER MY_VER_MAJOR,MY_VER_MINOR,MY_VER_BUILD,0

+

+#ifdef DEBUG

+#define DBG_FL VS_FF_DEBUG

+#else

+#define DBG_FL 0

+#endif

+

+#define MY_VERSION_INFO(fileType, descr, intName, origName)  \

+LANGUAGE 9, 1 \

+1 VERSIONINFO \

+  FILEVERSION MY_VER \

+  PRODUCTVERSION MY_VER \

+  FILEFLAGSMASK MY_VS_FFI_FILEFLAGSMASK \

+  FILEFLAGS DBG_FL \

+  FILEOS MY_VOS_NT_WINDOWS32 \

+  FILETYPE fileType \

+  FILESUBTYPE 0x0L \

+BEGIN \

+    BLOCK "StringFileInfo" \

+    BEGIN  \

+        BLOCK "040904b0" \

+        BEGIN \

+            VALUE "CompanyName", "Igor Pavlov" \

+            VALUE "FileDescription", descr \

+            VALUE "FileVersion", MY_VERSION  \

+            VALUE "InternalName", intName \

+            VALUE "LegalCopyright", MY_COPYRIGHT \

+            VALUE "OriginalFilename", origName \

+            VALUE "ProductName", "7-Zip" \

+            VALUE "ProductVersion", MY_VERSION \

+        END \

+    END \

+    BLOCK "VarFileInfo" \

+    BEGIN \

+        VALUE "Translation", 0x409, 1200 \

+    END \

+END

+

+#define MY_VERSION_INFO_APP(descr, intName) MY_VERSION_INFO(MY_VFT_APP, descr, intName, intName ".exe")

+

+#define MY_VERSION_INFO_DLL(descr, intName) MY_VERSION_INFO(MY_VFT_DLL, descr, intName, intName ".dll")

diff --git a/C/Aes.c b/C/Aes.c
new file mode 100644
index 0000000..06bf9d3
--- /dev/null
+++ b/C/Aes.c
@@ -0,0 +1,284 @@
+/* Aes.c -- AES encryption / decryption

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

+

+#include "Aes.h"

+#include "CpuArch.h"

+

+static UInt32 T[256 * 4];

+static Byte Sbox[256] = {

+  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,

+  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,

+  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,

+  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,

+  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,

+  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,

+  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,

+  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,

+  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,

+  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,

+  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,

+  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,

+  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,

+  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,

+  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,

+  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};

+

+void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);

+void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);

+void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);

+

+void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);

+void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);

+void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *ivAes, Byte *data, size_t numBlocks);

+

+AES_CODE_FUNC g_AesCbc_Encode;

+AES_CODE_FUNC g_AesCbc_Decode;

+AES_CODE_FUNC g_AesCtr_Code;

+

+static UInt32 D[256 * 4];

+static Byte InvS[256];

+

+static Byte Rcon[11] = { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };

+

+#define xtime(x) ((((x) << 1) ^ (((x) & 0x80) != 0 ? 0x1B : 0)) & 0xFF)

+

+#define Ui32(a0, a1, a2, a3) ((UInt32)(a0) | ((UInt32)(a1) << 8) | ((UInt32)(a2) << 16) | ((UInt32)(a3) << 24))

+

+#define gb0(x) ( (x)          & 0xFF)

+#define gb1(x) (((x) >> ( 8)) & 0xFF)

+#define gb2(x) (((x) >> (16)) & 0xFF)

+#define gb3(x) (((x) >> (24)) & 0xFF)

+

+void AesGenTables(void)

+{

+  unsigned i;

+  for (i = 0; i < 256; i++)

+    InvS[Sbox[i]] = (Byte)i;

+  for (i = 0; i < 256; i++)

+  {

+    {

+      UInt32 a1 = Sbox[i];

+      UInt32 a2 = xtime(a1);

+      UInt32 a3 = a2 ^ a1;

+      T[        i] = Ui32(a2, a1, a1, a3);

+      T[0x100 + i] = Ui32(a3, a2, a1, a1);

+      T[0x200 + i] = Ui32(a1, a3, a2, a1);

+      T[0x300 + i] = Ui32(a1, a1, a3, a2);

+    }

+    {

+      UInt32 a1 = InvS[i];

+      UInt32 a2 = xtime(a1);

+      UInt32 a4 = xtime(a2);

+      UInt32 a8 = xtime(a4);

+      UInt32 a9 = a8 ^ a1;

+      UInt32 aB = a8 ^ a2 ^ a1;

+      UInt32 aD = a8 ^ a4 ^ a1;

+      UInt32 aE = a8 ^ a4 ^ a2;

+      D[        i] = Ui32(aE, a9, aD, aB);

+      D[0x100 + i] = Ui32(aB, aE, a9, aD);

+      D[0x200 + i] = Ui32(aD, aB, aE, a9);

+      D[0x300 + i] = Ui32(a9, aD, aB, aE);

+    }

+  }

+  g_AesCbc_Encode = AesCbc_Encode;

+  g_AesCbc_Decode = AesCbc_Decode;

+  g_AesCtr_Code = AesCtr_Code;

+  #ifdef MY_CPU_X86_OR_AMD64

+  if (CPU_Is_Aes_Supported())

+  {

+    g_AesCbc_Encode = AesCbc_Encode_Intel;

+    g_AesCbc_Decode = AesCbc_Decode_Intel;

+    g_AesCtr_Code = AesCtr_Code_Intel;

+  }

+  #endif

+}

+

+#define HT(i, x, s) (T + (x << 8))[gb ## x(s[(i + x) & 3])]

+#define HT4(m, i, s, p) m[i] = \

+    HT(i, 0, s) ^ \

+    HT(i, 1, s) ^ \

+    HT(i, 2, s) ^ \

+    HT(i, 3, s) ^ w[p + i]

+/* such order (2031) in HT16 is for VC6/K8 speed optimization) */

+#define HT16(m, s, p) \

+    HT4(m, 2, s, p); \

+    HT4(m, 0, s, p); \

+    HT4(m, 3, s, p); \

+    HT4(m, 1, s, p); \

+

+#define FT(i, x) Sbox[gb ## x(m[(i + x) & 3])]

+#define FT4(i) dest[i] = Ui32(FT(i, 0), FT(i, 1), FT(i, 2), FT(i, 3)) ^ w[i];

+

+#define HD(i, x, s) (D + (x << 8))[gb ## x(s[(i - x) & 3])]

+#define HD4(m, i, s, p) m[i] = \

+    HD(i, 0, s) ^ \

+    HD(i, 1, s) ^ \

+    HD(i, 2, s) ^ \

+    HD(i, 3, s) ^ w[p + i];

+/* such order (0231) in HD16 is for VC6/K8 speed optimization) */

+#define HD16(m, s, p) \

+    HD4(m, 0, s, p); \

+    HD4(m, 2, s, p); \

+    HD4(m, 3, s, p); \

+    HD4(m, 1, s, p); \

+

+#define FD(i, x) InvS[gb ## x(m[(i - x) & 3])]

+#define FD4(i) dest[i] = Ui32(FD(i, 0), FD(i, 1), FD(i, 2), FD(i, 3)) ^ w[i];

+

+void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *w, const Byte *key, unsigned keySize)

+{

+  unsigned i, wSize;

+  wSize = keySize + 28;

+  keySize /= 4;

+  w[0] = ((UInt32)keySize / 2) + 3;

+  w += 4;

+

+  for (i = 0; i < keySize; i++, key += 4)

+    w[i] = GetUi32(key);

+

+  for (; i < wSize; i++)

+  {

+    UInt32 t = w[i - 1];

+    unsigned rem = i % keySize;

+    if (rem == 0)

+      t = Ui32(Sbox[gb1(t)] ^ Rcon[i / keySize], Sbox[gb2(t)], Sbox[gb3(t)], Sbox[gb0(t)]);

+    else if (keySize > 6 && rem == 4)

+      t = Ui32(Sbox[gb0(t)], Sbox[gb1(t)], Sbox[gb2(t)], Sbox[gb3(t)]);

+    w[i] = w[i - keySize] ^ t;

+  }

+}

+

+void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *w, const Byte *key, unsigned keySize)

+{

+  unsigned i, num;

+  Aes_SetKey_Enc(w, key, keySize);

+  num = keySize + 20;

+  w += 8;

+  for (i = 0; i < num; i++)

+  {

+    UInt32 r = w[i];

+    w[i] =

+      D[        Sbox[gb0(r)]] ^

+      D[0x100 + Sbox[gb1(r)]] ^

+      D[0x200 + Sbox[gb2(r)]] ^

+      D[0x300 + Sbox[gb3(r)]];

+  }

+}

+

+/* Aes_Encode and Aes_Decode functions work with little-endian words.

+  src and dest are pointers to 4 UInt32 words.

+  arc and dest can point to same block */

+

+static void Aes_Encode(const UInt32 *w, UInt32 *dest, const UInt32 *src)

+{

+  UInt32 s[4];

+  UInt32 m[4];

+  UInt32 numRounds2 = w[0];

+  w += 4;

+  s[0] = src[0] ^ w[0];

+  s[1] = src[1] ^ w[1];

+  s[2] = src[2] ^ w[2];

+  s[3] = src[3] ^ w[3];

+  w += 4;

+  for (;;)

+  {

+    HT16(m, s, 0);

+    if (--numRounds2 == 0)

+      break;

+    HT16(s, m, 4);

+    w += 8;

+  }

+  w += 4;

+  FT4(0); FT4(1); FT4(2); FT4(3);

+}

+

+static void Aes_Decode(const UInt32 *w, UInt32 *dest, const UInt32 *src)

+{

+  UInt32 s[4];

+  UInt32 m[4];

+  UInt32 numRounds2 = w[0];

+  w += 4 + numRounds2 * 8;

+  s[0] = src[0] ^ w[0];

+  s[1] = src[1] ^ w[1];

+  s[2] = src[2] ^ w[2];

+  s[3] = src[3] ^ w[3];

+  for (;;)

+  {

+    w -= 8;

+    HD16(m, s, 4);

+    if (--numRounds2 == 0)

+      break;

+    HD16(s, m, 0);

+  }

+  FD4(0); FD4(1); FD4(2); FD4(3);

+}

+

+void AesCbc_Init(UInt32 *p, const Byte *iv)

+{

+  unsigned i;

+  for (i = 0; i < 4; i++)

+    p[i] = GetUi32(iv + i * 4);

+}

+

+void MY_FAST_CALL AesCbc_Encode(UInt32 *p, Byte *data, size_t numBlocks)

+{

+  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)

+  {

+    p[0] ^= GetUi32(data);

+    p[1] ^= GetUi32(data + 4);

+    p[2] ^= GetUi32(data + 8);

+    p[3] ^= GetUi32(data + 12);

+    

+    Aes_Encode(p + 4, p, p);

+    

+    SetUi32(data,      p[0]);

+    SetUi32(data + 4,  p[1]);

+    SetUi32(data + 8,  p[2]);

+    SetUi32(data + 12, p[3]);

+  }

+}

+

+void MY_FAST_CALL AesCbc_Decode(UInt32 *p, Byte *data, size_t numBlocks)

+{

+  UInt32 in[4], out[4];

+  for (; numBlocks != 0; numBlocks--, data += AES_BLOCK_SIZE)

+  {

+    in[0] = GetUi32(data);

+    in[1] = GetUi32(data + 4);

+    in[2] = GetUi32(data + 8);

+    in[3] = GetUi32(data + 12);

+

+    Aes_Decode(p + 4, out, in);

+

+    SetUi32(data,      p[0] ^ out[0]);

+    SetUi32(data + 4,  p[1] ^ out[1]);

+    SetUi32(data + 8,  p[2] ^ out[2]);

+    SetUi32(data + 12, p[3] ^ out[3]);

+    

+    p[0] = in[0];

+    p[1] = in[1];

+    p[2] = in[2];

+    p[3] = in[3];

+  }

+}

+

+void MY_FAST_CALL AesCtr_Code(UInt32 *p, Byte *data, size_t numBlocks)

+{

+  for (; numBlocks != 0; numBlocks--)

+  {

+    UInt32 temp[4];

+    Byte buf[16];

+    int i;

+    if (++p[0] == 0)

+      p[1]++;

+    Aes_Encode(p + 4, temp, p);

+    SetUi32(buf,      temp[0]);

+    SetUi32(buf + 4,  temp[1]);

+    SetUi32(buf + 8,  temp[2]);

+    SetUi32(buf + 12, temp[3]);

+    for (i = 0; i < 16; i++)

+      *data++ ^= buf[i];

+  }

+}

diff --git a/C/Aes.h b/C/Aes.h
new file mode 100644
index 0000000..381e979
--- /dev/null
+++ b/C/Aes.h
@@ -0,0 +1,38 @@
+/* Aes.h -- AES encryption / decryption

+2013-01-18 : Igor Pavlov : Public domain */

+

+#ifndef __AES_H

+#define __AES_H

+

+#include "7zTypes.h"

+

+EXTERN_C_BEGIN

+

+#define AES_BLOCK_SIZE 16

+

+/* Call AesGenTables one time before other AES functions */

+void AesGenTables(void);

+

+/* UInt32 pointers must be 16-byte aligned */

+

+/* 16-byte (4 * 32-bit words) blocks: 1 (IV) + 1 (keyMode) + 15 (AES-256 roundKeys) */

+#define AES_NUM_IVMRK_WORDS ((1 + 1 + 15) * 4)

+

+/* aes - 16-byte aligned pointer to keyMode+roundKeys sequence */

+/* keySize = 16 or 24 or 32 (bytes) */

+typedef void (MY_FAST_CALL *AES_SET_KEY_FUNC)(UInt32 *aes, const Byte *key, unsigned keySize);

+void MY_FAST_CALL Aes_SetKey_Enc(UInt32 *aes, const Byte *key, unsigned keySize);

+void MY_FAST_CALL Aes_SetKey_Dec(UInt32 *aes, const Byte *key, unsigned keySize);

+

+/* ivAes - 16-byte aligned pointer to iv+keyMode+roundKeys sequence: UInt32[AES_NUM_IVMRK_WORDS] */

+void AesCbc_Init(UInt32 *ivAes, const Byte *iv); /* iv size is AES_BLOCK_SIZE */

+/* data - 16-byte aligned pointer to data */

+/* numBlocks - the number of 16-byte blocks in data array */

+typedef void (MY_FAST_CALL *AES_CODE_FUNC)(UInt32 *ivAes, Byte *data, size_t numBlocks);

+extern AES_CODE_FUNC g_AesCbc_Encode;

+extern AES_CODE_FUNC g_AesCbc_Decode;

+extern AES_CODE_FUNC g_AesCtr_Code;

+

+EXTERN_C_END

+

+#endif

diff --git a/C/AesOpt.c b/C/AesOpt.c
new file mode 100644
index 0000000..e5d4d26
--- /dev/null
+++ b/C/AesOpt.c
@@ -0,0 +1,184 @@
+/* AesOpt.c -- Intel's AES

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

+

+#include "CpuArch.h"

+

+#ifdef MY_CPU_X86_OR_AMD64

+#if _MSC_VER >= 1500

+#define USE_INTEL_AES

+#endif

+#endif

+

+#ifdef USE_INTEL_AES

+

+#include <wmmintrin.h>

+

+void MY_FAST_CALL AesCbc_Encode_Intel(__m128i *p, __m128i *data, size_t numBlocks)

+{

+  __m128i m = *p;

+  for (; numBlocks != 0; numBlocks--, data++)

+  {

+    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;

+    const __m128i *w = p + 3;

+    m = _mm_xor_si128(m, *data);

+    m = _mm_xor_si128(m, p[2]);

+    do

+    {

+      m = _mm_aesenc_si128(m, w[0]);

+      m = _mm_aesenc_si128(m, w[1]);

+      w += 2;

+    }

+    while (--numRounds2 != 0);

+    m = _mm_aesenc_si128(m, w[0]);

+    m = _mm_aesenclast_si128(m, w[1]);

+    *data = m;

+  }

+  *p = m;

+}

+

+#define NUM_WAYS 3

+

+#define AES_OP_W(op, n) { \

+    const __m128i t = w[n]; \

+    m0 = op(m0, t); \

+    m1 = op(m1, t); \

+    m2 = op(m2, t); \

+    }

+

+#define AES_DEC(n) AES_OP_W(_mm_aesdec_si128, n)

+#define AES_DEC_LAST(n) AES_OP_W(_mm_aesdeclast_si128, n)

+#define AES_ENC(n) AES_OP_W(_mm_aesenc_si128, n)

+#define AES_ENC_LAST(n) AES_OP_W(_mm_aesenclast_si128, n)

+

+void MY_FAST_CALL AesCbc_Decode_Intel(__m128i *p, __m128i *data, size_t numBlocks)

+{

+  __m128i iv = *p;

+  for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)

+  {

+    UInt32 numRounds2 = *(const UInt32 *)(p + 1);

+    const __m128i *w = p + numRounds2 * 2;

+    __m128i m0, m1, m2;

+    {

+      const __m128i t = w[2];

+      m0 = _mm_xor_si128(t, data[0]);

+      m1 = _mm_xor_si128(t, data[1]);

+      m2 = _mm_xor_si128(t, data[2]);

+    }

+    numRounds2--;

+    do

+    {

+      AES_DEC(1)

+      AES_DEC(0)

+      w -= 2;

+    }

+    while (--numRounds2 != 0);

+    AES_DEC(1)

+    AES_DEC_LAST(0)

+

+    {

+      __m128i t;

+      t = _mm_xor_si128(m0, iv); iv = data[0]; data[0] = t;

+      t = _mm_xor_si128(m1, iv); iv = data[1]; data[1] = t;

+      t = _mm_xor_si128(m2, iv); iv = data[2]; data[2] = t;

+    }

+  }

+  for (; numBlocks != 0; numBlocks--, data++)

+  {

+    UInt32 numRounds2 = *(const UInt32 *)(p + 1);

+    const __m128i *w = p + numRounds2 * 2;

+    __m128i m = _mm_xor_si128(w[2], *data);

+    numRounds2--;

+    do

+    {

+      m = _mm_aesdec_si128(m, w[1]);

+      m = _mm_aesdec_si128(m, w[0]);

+      w -= 2;

+    }

+    while (--numRounds2 != 0);

+    m = _mm_aesdec_si128(m, w[1]);

+    m = _mm_aesdeclast_si128(m, w[0]);

+

+    m = _mm_xor_si128(m, iv);

+    iv = *data;

+    *data = m;

+  }

+  *p = iv;

+}

+

+void MY_FAST_CALL AesCtr_Code_Intel(__m128i *p, __m128i *data, size_t numBlocks)

+{

+  __m128i ctr = *p;

+  __m128i one;

+  one.m128i_u64[0] = 1;

+  one.m128i_u64[1] = 0;

+  for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)

+  {

+    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;

+    const __m128i *w = p;

+    __m128i m0, m1, m2;

+    {

+      const __m128i t = w[2];

+      ctr = _mm_add_epi64(ctr, one); m0 = _mm_xor_si128(ctr, t);

+      ctr = _mm_add_epi64(ctr, one); m1 = _mm_xor_si128(ctr, t);

+      ctr = _mm_add_epi64(ctr, one); m2 = _mm_xor_si128(ctr, t);

+    }

+    w += 3;

+    do

+    {

+      AES_ENC(0)

+      AES_ENC(1)

+      w += 2;

+    }

+    while (--numRounds2 != 0);

+    AES_ENC(0)

+    AES_ENC_LAST(1)

+    data[0] = _mm_xor_si128(data[0], m0);

+    data[1] = _mm_xor_si128(data[1], m1);

+    data[2] = _mm_xor_si128(data[2], m2);

+  }

+  for (; numBlocks != 0; numBlocks--, data++)

+  {

+    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;

+    const __m128i *w = p;

+    __m128i m;

+    ctr = _mm_add_epi64(ctr, one);

+    m = _mm_xor_si128(ctr, p[2]);

+    w += 3;

+    do

+    {

+      m = _mm_aesenc_si128(m, w[0]);

+      m = _mm_aesenc_si128(m, w[1]);

+      w += 2;

+    }

+    while (--numRounds2 != 0);

+    m = _mm_aesenc_si128(m, w[0]);

+    m = _mm_aesenclast_si128(m, w[1]);

+    *data = _mm_xor_si128(*data, m);

+  }

+  *p = ctr;

+}

+

+#else

+

+void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);

+void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);

+void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);

+

+void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *p, Byte *data, size_t numBlocks)

+{

+  AesCbc_Encode(p, data, numBlocks);

+}

+

+void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *p, Byte *data, size_t numBlocks)

+{

+  AesCbc_Decode(p, data, numBlocks);

+}

+

+void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *p, Byte *data, size_t numBlocks)

+{

+  AesCtr_Code(p, data, numBlocks);

+}

+

+#endif

diff --git a/C/Alloc.c b/C/Alloc.c
index bb24a77..8e2839a 100755..100644
--- a/C/Alloc.c
+++ b/C/Alloc.c
@@ -1,7 +1,7 @@
 /* Alloc.c -- Memory allocation functions

-2008-09-24

-Igor Pavlov

-Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #ifdef _WIN32

 #include <windows.h>

diff --git a/C/Alloc.h b/C/Alloc.h
index 6b3f034..6b3f034 100755..100644
--- a/C/Alloc.h
+++ b/C/Alloc.h
diff --git a/C/Bcj2.c b/C/Bcj2.c
index 474bdd4..ac4ca0c 100755..100644
--- a/C/Bcj2.c
+++ b/C/Bcj2.c
@@ -1,6 +1,8 @@
 /* Bcj2.c -- Converter for x86 code (BCJ2)

 2008-10-04 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include "Bcj2.h"

 

 #ifdef _LZMA_PROB32

diff --git a/C/Bcj2.h b/C/Bcj2.h
index d9d857b..e8304c5 100755..100644
--- a/C/Bcj2.h
+++ b/C/Bcj2.h
@@ -1,14 +1,12 @@
 /* Bcj2.h -- Converter for x86 code (BCJ2)

-2009-02-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __BCJ2_H

 #define __BCJ2_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 /*

 Conditions:

@@ -31,8 +29,6 @@ int Bcj2_Decode(
     const Byte *buf3, SizeT size3,

     Byte *outBuf, SizeT outSize);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/Bra.c b/C/Bra.c
index 2a0f147..976810c 100755..100644
--- a/C/Bra.c
+++ b/C/Bra.c
@@ -1,6 +1,8 @@
 /* Bra.c -- Converters for RISC code

 2010-04-16 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include "Bra.h"

 

 SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)

diff --git a/C/Bra.h b/C/Bra.h
index 9c91e33..aba8dce 100755..100644
--- a/C/Bra.h
+++ b/C/Bra.h
@@ -1,14 +1,12 @@
 /* Bra.h -- Branch converters for executables

-2009-02-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __BRA_H

 #define __BRA_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 /*

 These functions convert relative addresses to absolute addresses

@@ -61,8 +59,6 @@ SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
 SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);

 SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/Bra86.c b/C/Bra86.c
index 93566cb..8dd3ed4 100755..100644
--- a/C/Bra86.c
+++ b/C/Bra86.c
@@ -1,85 +1,82 @@
 /* Bra86.c -- Converter for x86 code (BCJ)

-2008-10-04 : Igor Pavlov : Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

 

-#include "Bra.h"

+#include "Precomp.h"

 

-#define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)

+#include "Bra.h"

 

-const Byte kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};

-const Byte kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};

+#define Test86MSByte(b) ((((b) + 1) & 0xFE) == 0)

 

 SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding)

 {

-  SizeT bufferPos = 0, prevPosT;

-  UInt32 prevMask = *state & 0x7;

+  SizeT pos = 0;

+  UInt32 mask = *state & 7;

   if (size < 5)

     return 0;

+  size -= 4;

   ip += 5;

-  prevPosT = (SizeT)0 - 1;

 

   for (;;)

   {

-    Byte *p = data + bufferPos;

-    Byte *limit = data + size - 4;

+    Byte *p = data + pos;

+    const Byte *limit = data + size;

     for (; p < limit; p++)

       if ((*p & 0xFE) == 0xE8)

         break;

-    bufferPos = (SizeT)(p - data);

-    if (p >= limit)

-      break;

-    prevPosT = bufferPos - prevPosT;

-    if (prevPosT > 3)

-      prevMask = 0;

-    else

+

     {

-      prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7;

-      if (prevMask != 0)

+      SizeT d = (SizeT)(p - data - pos);

+      pos = (SizeT)(p - data);

+      if (p >= limit)

       {

-        Byte b = p[4 - kMaskToBitNumber[prevMask]];

-        if (!kMaskToAllowedStatus[prevMask] || Test86MSByte(b))

+        *state = (d > 2 ? 0 : mask >> (unsigned)d);

+        return pos;

+      }

+      if (d > 2)

+        mask = 0;

+      else

+      {

+        mask >>= (unsigned)d;

+        if (mask != 0 && (mask > 4 || mask == 3 || Test86MSByte(p[(mask >> 1) + 1])))

         {

-          prevPosT = bufferPos;

-          prevMask = ((prevMask << 1) & 0x7) | 1;

-          bufferPos++;

+          mask = (mask >> 1) | 4;

+          pos++;

           continue;

         }

       }

     }

-    prevPosT = bufferPos;

 

     if (Test86MSByte(p[4]))

     {

-      UInt32 src = ((UInt32)p[4] << 24) | ((UInt32)p[3] << 16) | ((UInt32)p[2] << 8) | ((UInt32)p[1]);

-      UInt32 dest;

-      for (;;)

+      UInt32 v = ((UInt32)p[4] << 24) | ((UInt32)p[3] << 16) | ((UInt32)p[2] << 8) | ((UInt32)p[1]);

+      UInt32 cur = ip + (UInt32)pos;

+      pos += 5;

+      if (encoding)

+        v += cur;

+      else

+        v -= cur;

+      if (mask != 0)

       {

-        Byte b;

-        int index;

-        if (encoding)

-          dest = (ip + (UInt32)bufferPos) + src;

-        else

-          dest = src - (ip + (UInt32)bufferPos);

-        if (prevMask == 0)

-          break;

-        index = kMaskToBitNumber[prevMask] * 8;

-        b = (Byte)(dest >> (24 - index));

-        if (!Test86MSByte(b))

-          break;

-        src = dest ^ ((1 << (32 - index)) - 1);

+        unsigned sh = (mask & 6) << 2;

+        if (Test86MSByte((Byte)(v >> sh)))

+        {

+          v ^= (((UInt32)0x100 << sh) - 1);

+          if (encoding)

+            v += cur;

+          else

+            v -= cur;

+        }

+        mask = 0;

       }

-      p[4] = (Byte)(~(((dest >> 24) & 1) - 1));

-      p[3] = (Byte)(dest >> 16);

-      p[2] = (Byte)(dest >> 8);

-      p[1] = (Byte)dest;

-      bufferPos += 5;

+      p[1] = (Byte)v;

+      p[2] = (Byte)(v >> 8);

+      p[3] = (Byte)(v >> 16);

+      p[4] = (Byte)(0 - ((v >> 24) & 1));

     }

     else

     {

-      prevMask = ((prevMask << 1) & 0x7) | 1;

-      bufferPos++;

+      mask = (mask >> 1) | 4;

+      pos++;

     }

   }

-  prevPosT = bufferPos - prevPosT;

-  *state = ((prevPosT > 3) ? 0 : ((prevMask << ((int)prevPosT - 1)) & 0x7));

-  return bufferPos;

 }

diff --git a/C/BraIA64.c b/C/BraIA64.c
index f359f16..813830c 100755..100644
--- a/C/BraIA64.c
+++ b/C/BraIA64.c
@@ -1,5 +1,7 @@
 /* BraIA64.c -- Converter for IA-64 code

-2008-10-04 : Igor Pavlov : Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include "Bra.h"

 

diff --git a/C/Compiler.h b/C/Compiler.h
new file mode 100644
index 0000000..0f76670
--- /dev/null
+++ b/C/Compiler.h
@@ -0,0 +1,28 @@
+/* Compiler.h -- Compiler ypes

+2013-11-12 : Igor Pavlov : Public domain */

+

+#ifndef __7Z_COMPILER_H

+#define __7Z_COMPILER_H

+

+#ifdef _MSC_VER

+

+  #ifdef UNDER_CE

+    #define RPC_NO_WINDOWS_H

+    /* #pragma warning(disable : 4115) // '_RPC_ASYNC_STATE' : named type definition in parentheses */

+    #pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union

+    #pragma warning(disable : 4214) // nonstandard extension used : bit field types other than int

+  #endif

+

+  #if _MSC_VER >= 1300

+    #pragma warning(disable : 4996) // This function or variable may be unsafe

+  #else

+    #pragma warning(disable : 4511) // copy constructor could not be generated

+    #pragma warning(disable : 4512) // assignment operator could not be generated

+    #pragma warning(disable : 4702) // unreachable code

+    #pragma warning(disable : 4710) // not inlined

+    #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information

+  #endif

+

+#endif

+

+#endif

diff --git a/C/CpuArch.c b/C/CpuArch.c
index 36e7680..f8ac0c2 100755..100644
--- a/C/CpuArch.c
+++ b/C/CpuArch.c
@@ -1,5 +1,7 @@
 /* CpuArch.c -- CPU specific code

-2010-10-26: Igor Pavlov : Public domain */

+2012-05-29: Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include "CpuArch.h"

 

@@ -9,6 +11,10 @@
 #define USE_ASM

 #endif

 

+#if !defined(USE_ASM) && _MSC_VER >= 1500

+#include <intrin.h>

+#endif

+

 #if defined(USE_ASM) && !defined(MY_CPU_AMD64)

 static UInt32 CheckFlag(UInt32 flag)

 {

@@ -73,9 +79,17 @@ static void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)
   #else

 

   __asm__ __volatile__ (

+  #if defined(MY_CPU_X86) && defined(__PIC__)

+    "mov %%ebx, %%edi;"

+    "cpuid;"

+    "xchgl %%ebx, %%edi;"

+    : "=a" (*a) ,

+      "=D" (*b) ,

+  #else

     "cpuid"

     : "=a" (*a) ,

       "=b" (*b) ,

+  #endif

       "=c" (*c) ,

       "=d" (*d)

     : "0" (function)) ;

@@ -135,7 +149,14 @@ Bool CPU_Is_InOrder()
   firm = x86cpuid_GetFirm(&p);

   switch (firm)

   {

-    case CPU_FIRM_INTEL: return (family < 6 || (family == 6 && model == 0x100C));

+    case CPU_FIRM_INTEL: return (family < 6 || (family == 6 && (

+        /* Atom CPU */

+           model == 0x100C  /* 45 nm, N4xx, D4xx, N5xx, D5xx, 230, 330 */

+        || model == 0x2006  /* 45 nm, Z6xx */

+        || model == 0x2007  /* 32 nm, Z2460 */

+        || model == 0x3005  /* 32 nm, Z2760 */

+        || model == 0x3006  /* 32 nm, N2xxx, D2xxx */

+        )));

     case CPU_FIRM_AMD: return (family < 5 || (family == 5 && (model < 6 || model == 0xA)));

     case CPU_FIRM_VIA: return (family < 6 || (family == 6 && model < 0xF));

   }

@@ -143,6 +164,7 @@ Bool CPU_Is_InOrder()
 }

 

 #if !defined(MY_CPU_AMD64) && defined(_WIN32)

+#include <windows.h>

 static Bool CPU_Sys_Is_SSE_Supported()

 {

   OSVERSIONINFO vi;

diff --git a/C/CpuArch.h b/C/CpuArch.h
index 0a709bb..2316205 100755..100644
--- a/C/CpuArch.h
+++ b/C/CpuArch.h
@@ -1,10 +1,10 @@
 /* CpuArch.h -- CPU specific code

-2010-10-26: Igor Pavlov : Public domain */

+2013-11-12: Igor Pavlov : Public domain */

 

 #ifndef __CPU_ARCH_H

 #define __CPU_ARCH_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

 EXTERN_C_BEGIN

 

@@ -52,7 +52,7 @@ If MY_CPU_LE_UNALIGN is not defined, we don't know about these properties of pla
 #define MY_CPU_LE

 #endif

 

-#if defined(__BIG_ENDIAN__)

+#if defined(__BIG_ENDIAN__) || defined(__m68k__) ||  defined(__ARMEB__) || defined(__MIPSEB__)

 #define MY_CPU_BE

 #endif

 

@@ -62,9 +62,9 @@ Stop_Compiling_Bad_Endian
 

 #ifdef MY_CPU_LE_UNALIGN

 

-#define GetUi16(p) (*(const UInt16 *)(p))

-#define GetUi32(p) (*(const UInt32 *)(p))

-#define GetUi64(p) (*(const UInt64 *)(p))

+#define GetUi16(p) (*(const UInt16 *)(const void *)(p))

+#define GetUi32(p) (*(const UInt32 *)(const void *)(p))

+#define GetUi64(p) (*(const UInt64 *)(const void *)(p))

 #define SetUi16(p, d) *(UInt16 *)(p) = (d);

 #define SetUi32(p, d) *(UInt32 *)(p) = (d);

 #define SetUi64(p, d) *(UInt64 *)(p) = (d);

@@ -99,6 +99,8 @@ Stop_Compiling_Bad_Endian
 

 #if defined(MY_CPU_LE_UNALIGN) && defined(_WIN64) && (_MSC_VER >= 1300)

 

+#include <stdlib.h>

+

 #pragma intrinsic(_byteswap_ulong)

 #pragma intrinsic(_byteswap_uint64)

 #define GetBe32(p) _byteswap_ulong(*(const UInt32 *)(const Byte *)(p))

@@ -116,7 +118,7 @@ Stop_Compiling_Bad_Endian
 

 #endif

 

-#define GetBe16(p) (((UInt16)((const Byte *)(p))[0] << 8) | ((const Byte *)(p))[1])

+#define GetBe16(p) ((UInt16)(((UInt16)((const Byte *)(p))[0] << 8) | ((const Byte *)(p))[1]))

 

 

 #ifdef MY_CPU_X86_OR_AMD64

diff --git a/C/Delta.c b/C/Delta.c
index 93c93a1..6cbbe46 100755..100644
--- a/C/Delta.c
+++ b/C/Delta.c
@@ -1,6 +1,8 @@
 /* Delta.c -- Delta converter

 2009-05-26 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include "Delta.h"

 

 void Delta_Init(Byte *state)

diff --git a/C/Delta.h b/C/Delta.h
index 776cd45..e59d5a2 100755..100644
--- a/C/Delta.h
+++ b/C/Delta.h
@@ -1,14 +1,12 @@
 /* Delta.h -- Delta converter

-2009-04-15 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __DELTA_H

 #define __DELTA_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 #define DELTA_STATE_SIZE 256

 

@@ -16,8 +14,6 @@ void Delta_Init(Byte *state);
 void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size);

 void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/LzFind.c b/C/LzFind.c
index f6c9e66..df79867 100755..100644
--- a/C/LzFind.c
+++ b/C/LzFind.c
@@ -1,6 +1,8 @@
 /* LzFind.c -- Match finder for LZ algorithms

 2009-04-22 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include <string.h>

 

 #include "LzFind.h"

diff --git a/C/LzFind.h b/C/LzFind.h
index 7ebdfa4..bad5000 100755..100644
--- a/C/LzFind.h
+++ b/C/LzFind.h
@@ -1,14 +1,12 @@
 /* LzFind.h -- Match finder for LZ algorithms

-2009-04-22 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZ_FIND_H

 #define __LZ_FIND_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 typedef UInt32 CLzRef;

 

@@ -108,8 +106,6 @@ UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
 void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);

 void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/LzFindMt.c b/C/LzFindMt.c
index db95590..5356d4a 100755..100644
--- a/C/LzFindMt.c
+++ b/C/LzFindMt.c
@@ -1,5 +1,7 @@
 /* LzFindMt.c -- multithreaded Match finder for LZ algorithms

-2009-09-20 : Igor Pavlov : Public domain */

+2014-12-29 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include "LzHash.h"

 

@@ -97,7 +99,7 @@ void MtSync_Destruct(CMtSync *p)
 

 #define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }

 

-static SRes MtSync_Create2(CMtSync *p, unsigned (MY_STD_CALL *startAddress)(void *), void *obj, UInt32 numBlocks)

+static SRes MtSync_Create2(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj, UInt32 numBlocks)

 {

   if (p->wasCreated)

     return SZ_OK;

@@ -119,7 +121,7 @@ static SRes MtSync_Create2(CMtSync *p, unsigned (MY_STD_CALL *startAddress)(void
   return SZ_OK;

 }

 

-static SRes MtSync_Create(CMtSync *p, unsigned (MY_STD_CALL *startAddress)(void *), void *obj, UInt32 numBlocks)

+static SRes MtSync_Create(CMtSync *p, THREAD_FUNC_TYPE startAddress, void *obj, UInt32 numBlocks)

 {

   SRes res = MtSync_Create2(p, startAddress, obj, numBlocks);

   if (res != SZ_OK)

@@ -451,13 +453,12 @@ void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAlloc *alloc)
 #define kHashBufferSize (kMtHashBlockSize * kMtHashNumBlocks)

 #define kBtBufferSize (kMtBtBlockSize * kMtBtNumBlocks)

 

-static unsigned MY_STD_CALL HashThreadFunc2(void *p) { HashThreadFunc((CMatchFinderMt *)p);  return 0; }

-static unsigned MY_STD_CALL BtThreadFunc2(void *p)

+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE HashThreadFunc2(void *p) { HashThreadFunc((CMatchFinderMt *)p);  return 0; }

+static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE BtThreadFunc2(void *p)

 {

   Byte allocaDummy[0x180];

-  int i = 0;

-  for (i = 0; i < 16; i++)

-    allocaDummy[i] = (Byte)i;

+  allocaDummy[0] = 0;

+  allocaDummy[1] = allocaDummy[0];

   BtThreadFunc((CMatchFinderMt *)p);

   return 0;

 }

diff --git a/C/LzFindMt.h b/C/LzFindMt.h
index 17ed237..320d87c 100755..100644
--- a/C/LzFindMt.h
+++ b/C/LzFindMt.h
@@ -1,5 +1,5 @@
 /* LzFindMt.h -- multithreaded Match finder for LZ algorithms

-2009-02-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZ_FIND_MT_H

 #define __LZ_FIND_MT_H

@@ -7,9 +7,7 @@
 #include "LzFind.h"

 #include "Threads.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 #define kMtHashBlockSize (1 << 13)

 #define kMtHashNumBlocks (1 << 3)

@@ -98,8 +96,6 @@ SRes MatchFinderMt_Create(CMatchFinderMt *p, UInt32 historySize, UInt32 keepAddB
 void MatchFinderMt_CreateVTable(CMatchFinderMt *p, IMatchFinder *vTable);

 void MatchFinderMt_ReleaseStream(CMatchFinderMt *p);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/LzHash.h b/C/LzHash.h
index b2f0e3c..b2f0e3c 100755..100644
--- a/C/LzHash.h
+++ b/C/LzHash.h
diff --git a/C/Lzma2Dec.c b/C/Lzma2Dec.c
index 8f24067..ed91619 100755..100644
--- a/C/Lzma2Dec.c
+++ b/C/Lzma2Dec.c
@@ -1,8 +1,10 @@
 /* Lzma2Dec.c -- LZMA2 Decoder

-2009-05-03 : Igor Pavlov : Public domain */

+2010-12-15 : Igor Pavlov : Public domain */

 

 /* #define SHOW_DEBUG_INFO */

 

+#include "Precomp.h"

+

 #ifdef SHOW_DEBUG_INFO

 #include <stdio.h>

 #endif

@@ -330,27 +332,21 @@ SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *
 SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,

     Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc)

 {

-  CLzma2Dec decoder;

+  CLzma2Dec p;

   SRes res;

   SizeT outSize = *destLen, inSize = *srcLen;

-  Byte props[LZMA_PROPS_SIZE];

-

-  Lzma2Dec_Construct(&decoder);

-

   *destLen = *srcLen = 0;

   *status = LZMA_STATUS_NOT_SPECIFIED;

-  decoder.decoder.dic = dest;

-  decoder.decoder.dicBufSize = outSize;

-

-  RINOK(Lzma2Dec_GetOldProps(prop, props));

-  RINOK(LzmaDec_AllocateProbs(&decoder.decoder, props, LZMA_PROPS_SIZE, alloc));

-  

+  Lzma2Dec_Construct(&p);

+  RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc));

+  p.decoder.dic = dest;

+  p.decoder.dicBufSize = outSize;

+  Lzma2Dec_Init(&p);

   *srcLen = inSize;

-  res = Lzma2Dec_DecodeToDic(&decoder, outSize, src, srcLen, finishMode, status);

-  *destLen = decoder.decoder.dicPos;

+  res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);

+  *destLen = p.decoder.dicPos;

   if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)

     res = SZ_ERROR_INPUT_EOF;

-

-  LzmaDec_FreeProbs(&decoder.decoder, alloc);

+  Lzma2Dec_FreeProbs(&p, alloc);

   return res;

 }

diff --git a/C/Lzma2Dec.h b/C/Lzma2Dec.h
index 827698d..9254523 100755..100644
--- a/C/Lzma2Dec.h
+++ b/C/Lzma2Dec.h
@@ -1,14 +1,12 @@
 /* Lzma2Dec.h -- LZMA2 Decoder

-2009-05-03 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZMA2_DEC_H

 #define __LZMA2_DEC_H

 

 #include "LzmaDec.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 /* ---------- State Interface ---------- */

 

@@ -77,8 +75,6 @@ Returns:
 SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,

     Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/Lzma2Enc.c b/C/Lzma2Enc.c
index 35f6ed7..34a97f3 100755..100644
--- a/C/Lzma2Enc.c
+++ b/C/Lzma2Enc.c
@@ -1,5 +1,7 @@
 /* Lzma2Enc.c -- LZMA2 Encoder

-2010-09-24 : Igor Pavlov : Public domain */

+2012-06-19 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 /* #include <stdio.h> */

 #include <string.h>

@@ -216,8 +218,7 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
     t3 = t1n * t2;

 

   p->lzmaProps.numThreads = t1;

-  p->numBlockThreads = t2;

-  p->numTotalThreads = t3;

+

   LzmaEncProps_Normalize(&p->lzmaProps);

 

   if (p->blockSize == 0)

@@ -231,6 +232,21 @@ void Lzma2EncProps_Normalize(CLzma2EncProps *p)
     if (blockSize < dictSize) blockSize = dictSize;

     p->blockSize = (size_t)blockSize;

   }

+  if (t2 > 1)

+  {

+    UInt64 temp = p->lzmaProps.reduceSize + p->blockSize - 1;

+    if (temp > p->lzmaProps.reduceSize)

+    {

+      UInt64 numBlocks = temp / p->blockSize;

+      if (numBlocks < t2)

+      {

+        t2 = (UInt32)numBlocks;

+        t3 = t1 * t2;

+      }

+    }

+  }

+  p->numBlockThreads = t2;

+  p->numTotalThreads = t3;

 }

 

 static SRes Progress(ICompressProgress *p, UInt64 inSize, UInt64 outSize)

diff --git a/C/Lzma2Enc.h b/C/Lzma2Enc.h
index 38830e5..061178a 100755..100644
--- a/C/Lzma2Enc.h
+++ b/C/Lzma2Enc.h
@@ -1,14 +1,12 @@
 /* Lzma2Enc.h -- LZMA2 Encoder

-2009-02-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZMA2_ENC_H

 #define __LZMA2_ENC_H

 

 #include "LzmaEnc.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 typedef struct

 {

@@ -59,8 +57,6 @@ SRes Lzma2Encode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
     ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);

 */

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/Lzma86.h b/C/Lzma86.h
index 6425bb8..83057e5 100755..100644
--- a/C/Lzma86.h
+++ b/C/Lzma86.h
@@ -1,10 +1,10 @@
 /* Lzma86.h -- LZMA + x86 (BCJ) Filter

-2009-08-14 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZMA86_H

 #define __LZMA86_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

 EXTERN_C_BEGIN

 

diff --git a/C/Lzma86Dec.c b/C/Lzma86Dec.c
index 760a447..760a447 100755..100644
--- a/C/Lzma86Dec.c
+++ b/C/Lzma86Dec.c
diff --git a/C/Lzma86Enc.c b/C/Lzma86Enc.c
index a29c605..41b488c 100755..100644
--- a/C/Lzma86Enc.c
+++ b/C/Lzma86Enc.c
@@ -99,7 +99,7 @@ int Lzma86_Encode(Byte *dest, size_t *destLen, const Byte *src, size_t srcLen,
         }

       }

     }

-    dest[0] = (bestIsFiltered ? 1 : 0);

+    dest[0] = (Byte)(bestIsFiltered ? 1 : 0);

     *destLen = LZMA86_HEADER_SIZE + minSize;

   }

   if (useFilter)

diff --git a/C/LzmaDec.c b/C/LzmaDec.c
index 4fdc11d..38cd9d6 100755..100644
--- a/C/LzmaDec.c
+++ b/C/LzmaDec.c
@@ -1,5 +1,7 @@
 /* LzmaDec.c -- LZMA Decoder

-2009-09-20 : Igor Pavlov : Public domain */

+2015-01-01 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include "LzmaDec.h"

 

@@ -44,6 +46,13 @@
   i -= 0x40; }

 #endif

 

+#define NORMAL_LITER_DEC GET_BIT(prob + symbol, symbol)

+#define MATCHED_LITER_DEC \

+  matchByte <<= 1; \

+  bit = (matchByte & offs); \

+  probLit = prob + offs + bit + symbol; \

+  GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)

+

 #define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }

 

 #define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)

@@ -171,24 +180,47 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
       {

         state -= (state < 4) ? state : 3;

         symbol = 1;

-        do { GET_BIT(prob + symbol, symbol) } while (symbol < 0x100);

+        #ifdef _LZMA_SIZE_OPT

+        do { NORMAL_LITER_DEC } while (symbol < 0x100);

+        #else

+        NORMAL_LITER_DEC

+        NORMAL_LITER_DEC

+        NORMAL_LITER_DEC

+        NORMAL_LITER_DEC

+        NORMAL_LITER_DEC

+        NORMAL_LITER_DEC

+        NORMAL_LITER_DEC

+        NORMAL_LITER_DEC

+        #endif

       }

       else

       {

-        unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];

+        unsigned matchByte = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];

         unsigned offs = 0x100;

         state -= (state < 10) ? 3 : 6;

         symbol = 1;

+        #ifdef _LZMA_SIZE_OPT

         do

         {

           unsigned bit;

           CLzmaProb *probLit;

-          matchByte <<= 1;

-          bit = (matchByte & offs);

-          probLit = prob + offs + bit + symbol;

-          GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)

+          MATCHED_LITER_DEC

         }

         while (symbol < 0x100);

+        #else

+        {

+          unsigned bit;

+          CLzmaProb *probLit;

+          MATCHED_LITER_DEC

+          MATCHED_LITER_DEC

+          MATCHED_LITER_DEC

+          MATCHED_LITER_DEC

+          MATCHED_LITER_DEC

+          MATCHED_LITER_DEC

+          MATCHED_LITER_DEC

+          MATCHED_LITER_DEC

+        }

+        #endif

       }

       dic[dicPos++] = (Byte)symbol;

       processedPos++;

@@ -442,8 +474,9 @@ static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
 

     p->processedPos += len;

     p->remainLen -= len;

-    while (len-- != 0)

+    while (len != 0)

     {

+      len--;

       dic[dicPos] = dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];

       dicPos++;

     }

@@ -972,28 +1005,21 @@ SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
 {

   CLzmaDec p;

   SRes res;

-  SizeT inSize = *srcLen;

-  SizeT outSize = *destLen;

-  *srcLen = *destLen = 0;

+  SizeT outSize = *destLen, inSize = *srcLen;

+  *destLen = *srcLen = 0;

+  *status = LZMA_STATUS_NOT_SPECIFIED;

   if (inSize < RC_INIT_SIZE)

     return SZ_ERROR_INPUT_EOF;

-

   LzmaDec_Construct(&p);

-  res = LzmaDec_AllocateProbs(&p, propData, propSize, alloc);

-  if (res != 0)

-    return res;

+  RINOK(LzmaDec_AllocateProbs(&p, propData, propSize, alloc));

   p.dic = dest;

   p.dicBufSize = outSize;

-

   LzmaDec_Init(&p);

-  

   *srcLen = inSize;

   res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);

-

+  *destLen = p.dicPos;

   if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)

     res = SZ_ERROR_INPUT_EOF;

-

-  (*destLen) = p.dicPos;

   LzmaDec_FreeProbs(&p, alloc);

   return res;

 }

diff --git a/C/LzmaDec.h b/C/LzmaDec.h
index 6741a64..2633abe 100755..100644
--- a/C/LzmaDec.h
+++ b/C/LzmaDec.h
@@ -1,14 +1,12 @@
 /* LzmaDec.h -- LZMA Decoder

-2009-02-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZMA_DEC_H

 #define __LZMA_DEC_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 /* #define _LZMA_PROB32 */

 /* _LZMA_PROB32 can increase the speed on some CPUs,

@@ -224,8 +222,6 @@ SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
     const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,

     ELzmaStatus *status, ISzAlloc *alloc);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/LzmaEnc.c b/C/LzmaEnc.c
index 9e6dbdb..40ee6a4 100755..100644
--- a/C/LzmaEnc.c
+++ b/C/LzmaEnc.c
@@ -1,5 +1,7 @@
 /* LzmaEnc.c -- LZMA Encoder

-2010-04-16 : Igor Pavlov : Public domain */

+2014-12-29 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include <string.h>

 

@@ -18,7 +20,7 @@
 #endif

 

 #ifdef SHOW_STAT

-static int ttt = 0;

+static unsigned g_STAT_OFFSET = 0;

 #endif

 

 #define kBlockSizeMax ((1 << LZMA_NUM_BLOCK_SIZE_BITS) - 1)

@@ -46,6 +48,7 @@ void LzmaEncProps_Init(CLzmaEncProps *p)
 {

   p->level = 5;

   p->dictSize = p->mc = 0;

+  p->reduceSize = (UInt64)(Int64)-1;

   p->lc = p->lp = p->pb = p->algo = p->fb = p->btMode = p->numHashBytes = p->numThreads = -1;

   p->writeEndMark = 0;

 }

@@ -56,6 +59,15 @@ void LzmaEncProps_Normalize(CLzmaEncProps *p)
   if (level < 0) level = 5;

   p->level = level;

   if (p->dictSize == 0) p->dictSize = (level <= 5 ? (1 << (level * 2 + 14)) : (level == 6 ? (1 << 25) : (1 << 26)));

+  if (p->dictSize > p->reduceSize)

+  {

+    unsigned i;

+    for (i = 11; i <= 30; i++)

+    {

+      if ((UInt32)p->reduceSize <= ((UInt32)2 << i)) { p->dictSize = ((UInt32)2 << i); break; }

+      if ((UInt32)p->reduceSize <= ((UInt32)3 << i)) { p->dictSize = ((UInt32)3 << i); break; }

+    }

+  }

   if (p->lc < 0) p->lc = 3;

   if (p->lp < 0) p->lp = 0;

   if (p->pb < 0) p->pb = 2;

@@ -329,7 +341,6 @@ typedef struct
 

   SRes result;

   UInt32 dictSize;

-  UInt32 matchFinderCycles;

 

   int needInit;

 

@@ -398,7 +409,6 @@ SRes LzmaEnc_SetProps(CLzmaEncHandle pp, const CLzmaEncProps *props2)
       props.dictSize > ((UInt32)1 << kDicLogSizeMaxCompress) || props.dictSize > ((UInt32)1 << 30))

     return SZ_ERROR_PARAM;

   p->dictSize = props.dictSize;

-  p->matchFinderCycles = props.mc;

   {

     unsigned fb = props.fb;

     if (fb < 5)

@@ -508,7 +518,7 @@ static void RangeEnc_FlushStream(CRangeEnc *p)
 

 static void MY_FAST_CALL RangeEnc_ShiftLow(CRangeEnc *p)

 {

-  if ((UInt32)p->low < (UInt32)0xFF000000 || (int)(p->low >> 32) != 0)

+  if ((UInt32)p->low < (UInt32)0xFF000000 || (unsigned)(p->low >> 32) != 0)

   {

     Byte temp = p->cache;

     do

@@ -534,7 +544,7 @@ static void RangeEnc_FlushData(CRangeEnc *p)
     RangeEnc_ShiftLow(p);

 }

 

-static void RangeEnc_EncodeDirectBits(CRangeEnc *p, UInt32 value, int numBits)

+static void RangeEnc_EncodeDirectBits(CRangeEnc *p, UInt32 value, unsigned numBits)

 {

   do

   {

@@ -803,9 +813,10 @@ static void LenEnc_Encode2(CLenPriceEnc *p, CRangeEnc *rc, UInt32 symbol, UInt32
 static void MovePos(CLzmaEnc *p, UInt32 num)

 {

   #ifdef SHOW_STAT

-  ttt += num;

+  g_STAT_OFFSET += num;

   printf("\n MovePos %d", num);

   #endif

+  

   if (num != 0)

   {

     p->additionalOffset += num;

@@ -818,15 +829,17 @@ static UInt32 ReadMatchDistances(CLzmaEnc *p, UInt32 *numDistancePairsRes)
   UInt32 lenRes = 0, numPairs;

   p->numAvail = p->matchFinder.GetNumAvailableBytes(p->matchFinderObj);

   numPairs = p->matchFinder.GetMatches(p->matchFinderObj, p->matches);

+  

   #ifdef SHOW_STAT

-  printf("\n i = %d numPairs = %d    ", ttt, numPairs / 2);

-  ttt++;

+  printf("\n i = %d numPairs = %d    ", g_STAT_OFFSET, numPairs / 2);

+  g_STAT_OFFSET++;

   {

     UInt32 i;

     for (i = 0; i < numPairs; i += 2)

       printf("%2d %6d   | ", p->matches[i], p->matches[i + 1]);

   }

   #endif

+  

   if (numPairs > 0)

   {

     lenRes = p->matches[numPairs - 2];

@@ -1897,12 +1910,10 @@ static SRes LzmaEnc_CodeOneBlock(CLzmaEnc *p, Bool useLimits, UInt32 maxPackSize
 static SRes LzmaEnc_Alloc(CLzmaEnc *p, UInt32 keepWindowSize, ISzAlloc *alloc, ISzAlloc *allocBig)

 {

   UInt32 beforeSize = kNumOpts;

-  Bool btMode;

   if (!RangeEnc_Alloc(&p->rc, alloc))

     return SZ_ERROR_MEM;

-  btMode = (p->matchFinderBase.btMode != 0);

   #ifndef _7ZIP_ST

-  p->mtMode = (p->multiThread && !p->fastMode && btMode);

+  p->mtMode = (p->multiThread && !p->fastMode && (p->matchFinderBase.btMode != 0));

   #endif

 

   {

@@ -2157,9 +2168,8 @@ static SRes LzmaEnc_Encode2(CLzmaEnc *p, ICompressProgress *progress)
 

   #ifndef _7ZIP_ST

   Byte allocaDummy[0x300];

-  int i = 0;

-  for (i = 0; i < 16; i++)

-    allocaDummy[i] = (Byte)i;

+  allocaDummy[0] = 0;

+  allocaDummy[1] = allocaDummy[0];

   #endif

 

   for (;;)

diff --git a/C/LzmaEnc.h b/C/LzmaEnc.h
index 999f5af..c2806b4 100755..100644
--- a/C/LzmaEnc.h
+++ b/C/LzmaEnc.h
@@ -1,14 +1,12 @@
 /*  LzmaEnc.h -- LZMA Encoder

-2009-02-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZMA_ENC_H

 #define __LZMA_ENC_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 #define LZMA_PROPS_SIZE 5

 

@@ -18,6 +16,8 @@ typedef struct _CLzmaEncProps
   UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version

                       (1 << 12) <= dictSize <= (1 << 30) for 64-bit version

                        default = (1 << 24) */

+  UInt64 reduceSize; /* estimated size of data that will be compressed. default = 0xFFFFFFFF.

+                        Encoder uses this value to reduce dictionary size */

   int lc;          /* 0 <= lc <= 8, default = 3 */

   int lp;          /* 0 <= lp <= 4, default = 0 */

   int pb;          /* 0 <= pb <= 4, default = 2 */

@@ -73,8 +73,6 @@ SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
     const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,

     ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/LzmaLib.c b/C/LzmaLib.c
index 3e3cf40..3e3cf40 100755..100644
--- a/C/LzmaLib.c
+++ b/C/LzmaLib.c
diff --git a/C/LzmaLib.h b/C/LzmaLib.h
index 55e1e11..5c35e53 100755..100644
--- a/C/LzmaLib.h
+++ b/C/LzmaLib.h
@@ -1,14 +1,12 @@
 /* LzmaLib.h -- LZMA library interface

-2009-04-07 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __LZMA_LIB_H

 #define __LZMA_LIB_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

 

 #define MY_STDAPI int MY_STD_CALL

 

@@ -128,8 +126,6 @@ Returns:
 MY_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,

   const unsigned char *props, size_t propsSize);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/MtCoder.c b/C/MtCoder.c
index 9f0d268..303b435 100755..100644
--- a/C/MtCoder.c
+++ b/C/MtCoder.c
@@ -1,6 +1,8 @@
 /* MtCoder.c -- Multi-thread Coder

 2010-09-24 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include <stdio.h>

 

 #include "MtCoder.h"

diff --git a/C/MtCoder.h b/C/MtCoder.h
index 705208e..705208e 100755..100644
--- a/C/MtCoder.h
+++ b/C/MtCoder.h
diff --git a/C/Ppmd.h b/C/Ppmd.h
index 14344a7..25ce2d2 100755..100644
--- a/C/Ppmd.h
+++ b/C/Ppmd.h
@@ -1,11 +1,10 @@
 /* Ppmd.h -- PPMD codec common code

-2010-03-12 : Igor Pavlov : Public domain

+2013-01-18 : Igor Pavlov : Public domain

 This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */

 

 #ifndef __PPMD_H

 #define __PPMD_H

 

-#include "Types.h"

 #include "CpuArch.h"

 

 EXTERN_C_BEGIN

@@ -29,6 +28,9 @@ EXTERN_C_BEGIN
 #define PPMD_N4 ((128 + 3 - 1 * PPMD_N1 - 2 * PPMD_N2 - 3 * PPMD_N3) / 4)

 #define PPMD_NUM_INDEXES (PPMD_N1 + PPMD_N2 + PPMD_N3 + PPMD_N4)

 

+#pragma pack(push, 1)

+/* Most compilers works OK here even without #pragma pack(push, 1), but some GCC compilers need it. */

+

 /* SEE-contexts for PPM-contexts with masked symbols */

 typedef struct

 {

@@ -48,6 +50,8 @@ typedef struct
   UInt16 SuccessorHigh;

 } CPpmd_State;

 

+#pragma pack(pop)

+

 typedef

   #ifdef PPMD_32BIT

     CPpmd_State *

diff --git a/C/Ppmd7.c b/C/Ppmd7.c
index 4b160cf..798c118 100755..100644
--- a/C/Ppmd7.c
+++ b/C/Ppmd7.c
@@ -2,6 +2,8 @@
 2010-03-12 : Igor Pavlov : Public domain

 This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */

 

+#include "Precomp.h"

+

 #include <memory.h>

 

 #include "Ppmd7.h"

diff --git a/C/Ppmd7.h b/C/Ppmd7.h
index 56e81eb..56e81eb 100755..100644
--- a/C/Ppmd7.h
+++ b/C/Ppmd7.h
diff --git a/C/Ppmd7Dec.c b/C/Ppmd7Dec.c
index d6608e8..3d01d76 100755..100644
--- a/C/Ppmd7Dec.c
+++ b/C/Ppmd7Dec.c
@@ -2,6 +2,8 @@
 2010-03-12 : Igor Pavlov : Public domain

 This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */

 

+#include "Precomp.h"

+

 #include "Ppmd7.h"

 

 #define kTopValue (1 << 24)

diff --git a/C/Ppmd7Enc.c b/C/Ppmd7Enc.c
index b1fecae..d82ea90 100755..100644
--- a/C/Ppmd7Enc.c
+++ b/C/Ppmd7Enc.c
@@ -2,6 +2,8 @@
 2010-03-12 : Igor Pavlov : Public domain

 This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */

 

+#include "Precomp.h"

+

 #include "Ppmd7.h"

 

 #define kTopValue (1 << 24)

diff --git a/C/Precomp.h b/C/Precomp.h
new file mode 100644
index 0000000..edb5814
--- /dev/null
+++ b/C/Precomp.h
@@ -0,0 +1,10 @@
+/* Precomp.h -- StdAfx

+2013-11-12 : Igor Pavlov : Public domain */

+

+#ifndef __7Z_PRECOMP_H

+#define __7Z_PRECOMP_H

+

+#include "Compiler.h"

+/* #include "7zTypes.h" */

+

+#endif

diff --git a/C/RotateDefs.h b/C/RotateDefs.h
index ff9b722..ad7d164 100755..100644
--- a/C/RotateDefs.h
+++ b/C/RotateDefs.h
@@ -1,5 +1,5 @@
 /* RotateDefs.h -- Rotate functions

-2009-02-07 : Igor Pavlov : Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

 

 #ifndef __ROTATE_DEFS_H

 #define __ROTATE_DEFS_H

@@ -7,6 +7,12 @@
 #ifdef _MSC_VER

 

 #include <stdlib.h>

+

+// #if (_MSC_VER >= 1200)

+#pragma intrinsic(_rotl)

+#pragma intrinsic(_rotr)

+// #endif

+

 #define rotlFixed(x, n) _rotl((x), (n))

 #define rotrFixed(x, n) _rotr((x), (n))

 

diff --git a/C/Sha256.c b/C/Sha256.c
index cfb9eac..91208d3 100755..100644
--- a/C/Sha256.c
+++ b/C/Sha256.c
@@ -2,6 +2,8 @@
 2010-06-11 : Igor Pavlov : Public domain

 This code is based on public domain code from Wei Dai's Crypto++ library. */

 

+#include "Precomp.h"

+

 #include "RotateDefs.h"

 #include "Sha256.h"

 

diff --git a/C/Sha256.h b/C/Sha256.h
index 26d1e3a..7f17ccf 100755..100644
--- a/C/Sha256.h
+++ b/C/Sha256.h
@@ -1,10 +1,10 @@
 /* Sha256.h -- SHA-256 Hash

-2010-06-11 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __CRYPTO_SHA256_H

 #define __CRYPTO_SHA256_H

 

-#include "Types.h"

+#include "7zTypes.h"

 

 EXTERN_C_BEGIN

 

diff --git a/C/Sort.c b/C/Sort.c
new file mode 100644
index 0000000..73dcbf0
--- /dev/null
+++ b/C/Sort.c
@@ -0,0 +1,141 @@
+/* Sort.c -- Sort functions

+2014-04-05 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

+

+#include "Sort.h"

+

+#define HeapSortDown(p, k, size, temp) \

+  { for (;;) { \

+    size_t s = (k << 1); \

+    if (s > size) break; \

+    if (s < size && p[s + 1] > p[s]) s++; \

+    if (temp >= p[s]) break; \

+    p[k] = p[s]; k = s; \

+  } p[k] = temp; }

+

+void HeapSort(UInt32 *p, size_t size)

+{

+  if (size <= 1)

+    return;

+  p--;

+  {

+    size_t i = size / 2;

+    do

+    {

+      UInt32 temp = p[i];

+      size_t k = i;

+      HeapSortDown(p, k, size, temp)

+    }

+    while (--i != 0);

+  }

+  /*

+  do

+  {

+    size_t k = 1;

+    UInt32 temp = p[size];

+    p[size--] = p[1];

+    HeapSortDown(p, k, size, temp)

+  }

+  while (size > 1);

+  */

+  while (size > 3)

+  {

+    UInt32 temp = p[size];

+    size_t k = (p[3] > p[2]) ? 3 : 2;

+    p[size--] = p[1];

+    p[1] = p[k];

+    HeapSortDown(p, k, size, temp)

+  }

+  {

+    UInt32 temp = p[size];

+    p[size] = p[1];

+    if (size > 2 && p[2] < temp)

+    {

+      p[1] = p[2];

+      p[2] = temp;

+    }

+    else

+      p[1] = temp;

+  }

+}

+

+void HeapSort64(UInt64 *p, size_t size)

+{

+  if (size <= 1)

+    return;

+  p--;

+  {

+    size_t i = size / 2;

+    do

+    {

+      UInt64 temp = p[i];

+      size_t k = i;

+      HeapSortDown(p, k, size, temp)

+    }

+    while (--i != 0);

+  }

+  /*

+  do

+  {

+    size_t k = 1;

+    UInt64 temp = p[size];

+    p[size--] = p[1];

+    HeapSortDown(p, k, size, temp)

+  }

+  while (size > 1);

+  */

+  while (size > 3)

+  {

+    UInt64 temp = p[size];

+    size_t k = (p[3] > p[2]) ? 3 : 2;

+    p[size--] = p[1];

+    p[1] = p[k];

+    HeapSortDown(p, k, size, temp)

+  }

+  {

+    UInt64 temp = p[size];

+    p[size] = p[1];

+    if (size > 2 && p[2] < temp)

+    {

+      p[1] = p[2];

+      p[2] = temp;

+    }

+    else

+      p[1] = temp;

+  }

+}

+

+/*

+#define HeapSortRefDown(p, vals, n, size, temp) \

+  { size_t k = n; UInt32 val = vals[temp]; for (;;) { \

+    size_t s = (k << 1); \

+    if (s > size) break; \

+    if (s < size && vals[p[s + 1]] > vals[p[s]]) s++; \

+    if (val >= vals[p[s]]) break; \

+    p[k] = p[s]; k = s; \

+  } p[k] = temp; }

+

+void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size)

+{

+  if (size <= 1)

+    return;

+  p--;

+  {

+    size_t i = size / 2;

+    do

+    {

+      UInt32 temp = p[i];

+      HeapSortRefDown(p, vals, i, size, temp);

+    }

+    while (--i != 0);

+  }

+  do

+  {

+    UInt32 temp = p[size];

+    p[size--] = p[1];

+    HeapSortRefDown(p, vals, 1, size, temp);

+  }

+  while (size > 1);

+}

+*/

diff --git a/C/Sort.h b/C/Sort.h
new file mode 100644
index 0000000..7209d78
--- /dev/null
+++ b/C/Sort.h
@@ -0,0 +1,18 @@
+/* Sort.h -- Sort functions

+2014-04-05 : Igor Pavlov : Public domain */

+

+#ifndef __7Z_SORT_H

+#define __7Z_SORT_H

+

+#include "7zTypes.h"

+

+EXTERN_C_BEGIN

+

+void HeapSort(UInt32 *p, size_t size);

+void HeapSort64(UInt64 *p, size_t size);

+

+/* void HeapSortRef(UInt32 *p, UInt32 *vals, size_t size); */

+

+EXTERN_C_END

+

+#endif

diff --git a/C/Threads.c b/C/Threads.c
index 4be44fb..18ba1e8 100755..100644
--- a/C/Threads.c
+++ b/C/Threads.c
@@ -1,5 +1,7 @@
 /* Threads.c -- multithreading library

-2009-09-20 : Igor Pavlov : Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #ifndef _WIN32_WCE

 #include <process.h>

@@ -29,14 +31,21 @@ WRes Handle_WaitObject(HANDLE h) { return (WRes)WaitForSingleObject(h, INFINITE)
 

 WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param)

 {

-  unsigned threadId; /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */

-  *p =

-    #ifdef UNDER_CE

-    CreateThread(0, 0, func, param, 0, &threadId);

-    #else

-    (HANDLE)_beginthreadex(NULL, 0, func, param, 0, &threadId);

-    #endif

-    /* maybe we must use errno here, but probably GetLastError() is also OK. */

+  /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */

+  

+  #ifdef UNDER_CE

+  

+  DWORD threadId;

+  *p = CreateThread(0, 0, func, param, 0, &threadId);

+

+  #else

+

+  unsigned threadId;

+  *p = (HANDLE)_beginthreadex(NULL, 0, func, param, 0, &threadId);

+   

+  #endif

+

+  /* maybe we must use errno here, but probably GetLastError() is also OK. */

   return HandleToWRes(*p);

 }

 

diff --git a/C/Threads.h b/C/Threads.h
index 6a7afa8..e927208 100755..100644
--- a/C/Threads.h
+++ b/C/Threads.h
@@ -1,15 +1,17 @@
 /* Threads.h -- multithreading library

-2009-03-27 : Igor Pavlov : Public domain */

+2013-11-12 : Igor Pavlov : Public domain */

 

 #ifndef __7Z_THREADS_H

 #define __7Z_THREADS_H

 

-#include "Types.h"

-

-#ifdef __cplusplus

-extern "C" {

+#ifdef _WIN32

+#include <windows.h>

 #endif

 

+#include "7zTypes.h"

+

+EXTERN_C_BEGIN

+

 WRes HandlePtr_Close(HANDLE *h);

 WRes Handle_WaitObject(HANDLE h);

 

@@ -18,7 +20,15 @@ typedef HANDLE CThread;
 #define Thread_WasCreated(p) (*(p) != NULL)

 #define Thread_Close(p) HandlePtr_Close(p)

 #define Thread_Wait(p) Handle_WaitObject(*(p))

-typedef unsigned THREAD_FUNC_RET_TYPE;

+

+typedef

+#ifdef UNDER_CE

+  DWORD

+#else

+  unsigned

+#endif

+  THREAD_FUNC_RET_TYPE;

+

 #define THREAD_FUNC_CALL_TYPE MY_STD_CALL

 #define THREAD_FUNC_DECL THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE

 typedef THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE * THREAD_FUNC_TYPE)(void *);

@@ -52,8 +62,6 @@ WRes CriticalSection_Init(CCriticalSection *p);
 #define CriticalSection_Enter(p) EnterCriticalSection(p)

 #define CriticalSection_Leave(p) LeaveCriticalSection(p)

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/Util/7z/7z.dsp b/C/Util/7z/7z.dsp
index 9f5806b..73122f7 100755..100644
--- a/C/Util/7z/7z.dsp
+++ b/C/Util/7z/7z.dsp
@@ -42,7 +42,7 @@ RSC=rc.exe
 # PROP Ignore_Export_Lib 0

 # PROP Target_Dir ""

 # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

-# ADD CPP /nologo /MD /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /FAs /YX /FD /c

+# ADD CPP /nologo /MD /W4 /WX /GX /O2 /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /FAs /Yu"Precomp.h" /FD /c

 # ADD BASE RSC /l 0x419 /d "NDEBUG"

 # ADD RSC /l 0x419 /d "NDEBUG"

 BSC32=bscmake.exe

@@ -50,7 +50,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo

 LINK32=link.exe

 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"Release/7zDec.exe" /opt:NOWIN98

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"c:\util\7zDec.exe" /opt:NOWIN98

 # SUBTRACT LINK32 /pdb:none

 

 !ELSEIF  "$(CFG)" == "7z - Win32 Debug"

@@ -67,7 +67,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0

 # PROP Target_Dir ""

 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c

-# ADD CPP /nologo /W4 /Gm /GX /ZI /Od /D "_DEBUG" /D "_SZ_ALLOC_DEBUG2" /D "_SZ_NO_INT_64_A" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /YX /FD /GZ /c

+# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "_SZ_ALLOC_DEBUG2" /D "_SZ_NO_INT_64_A" /D "WIN32" /D "_CONSOLE" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /GZ /c

 # ADD BASE RSC /l 0x419 /d "_DEBUG"

 # ADD RSC /l 0x419 /d "_DEBUG"

 BSC32=bscmake.exe

@@ -75,7 +75,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo

 LINK32=link.exe

 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"Debug/7zDec.exe" /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /out:"c:\util\7zDec.exe" /pdbtype:sept

 

 !ENDIF 

 

@@ -100,6 +100,10 @@ SOURCE=..\..\7zAlloc.h
 # End Source File

 # Begin Source File

 

+SOURCE=..\..\7zArcIn.c

+# End Source File

+# Begin Source File

+

 SOURCE=..\..\7zBuf.c

 # End Source File

 # Begin Source File

@@ -133,11 +137,11 @@ SOURCE=..\..\7zFile.h
 # End Source File

 # Begin Source File

 

-SOURCE=..\..\7zIn.c

+SOURCE=..\..\7zStream.c

 # End Source File

 # Begin Source File

 

-SOURCE=..\..\7zStream.c

+SOURCE=..\..\7zTypes.h

 # End Source File

 # Begin Source File

 

@@ -190,7 +194,6 @@ SOURCE=..\..\Ppmd.h
 # Begin Source File

 

 SOURCE=..\..\Ppmd7.c

-# SUBTRACT CPP /YX

 # End Source File

 # Begin Source File

 

@@ -199,11 +202,23 @@ SOURCE=..\..\Ppmd7.h
 # Begin Source File

 

 SOURCE=..\..\Ppmd7Dec.c

-# SUBTRACT CPP /YX

+# End Source File

+# End Group

+# Begin Group "Spec"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\Compiler.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\Precomp.c

+# ADD CPP /Yc"Precomp.h"

 # End Source File

 # Begin Source File

 

-SOURCE=..\..\Types.h

+SOURCE=.\Precomp.h

 # End Source File

 # End Group

 # Begin Source File

diff --git a/C/Util/7z/7z.dsw b/C/Util/7z/7z.dsw
index 23089fb..23089fb 100755..100644
--- a/C/Util/7z/7z.dsw
+++ b/C/Util/7z/7z.dsw
diff --git a/C/Util/7z/7zMain.c b/C/Util/7z/7zMain.c
index f217340..736a7fe 100755..100644
--- a/C/Util/7z/7zMain.c
+++ b/C/Util/7z/7zMain.c
@@ -1,11 +1,14 @@
 /* 7zMain.c - Test application for 7z Decoder

-2010-10-28 : Igor Pavlov : Public domain */

+2015-01-02 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include <stdio.h>

 #include <string.h>

 

 #include "../../7z.h"

 #include "../../7zAlloc.h"

+#include "../../7zBuf.h"

 #include "../../7zCrc.h"

 #include "../../7zFile.h"

 #include "../../7zVersion.h"

@@ -95,42 +98,52 @@ static SRes Utf16_To_Utf8Buf(CBuf *dest, const UInt16 *src, size_t srcLen)
   dest->data[destLen] = 0;

   return res ? SZ_OK : SZ_ERROR_FAIL;

 }

+

 #endif

 

-static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s, int fileMode)

+static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s

+    #ifdef _WIN32

+    , UINT codePage

+    #endif

+    )

 {

-  int len = 0;

-  for (len = 0; s[len] != '\0'; len++);

+  unsigned len = 0;

+  for (len = 0; s[len] != 0; len++);

 

   #ifdef _WIN32

   {

-    int size = len * 3 + 100;

+    unsigned size = len * 3 + 100;

     if (!Buf_EnsureSize(buf, size))

       return SZ_ERROR_MEM;

     {

-      char defaultChar = '_';

-      BOOL defUsed;

-      int numChars = WideCharToMultiByte(fileMode ?

-          (

-          #ifdef UNDER_CE

-          CP_ACP

-          #else

-          AreFileApisANSI() ? CP_ACP : CP_OEMCP

-          #endif

-          ) : CP_OEMCP,

-          0, s, len, (char *)buf->data, size, &defaultChar, &defUsed);

-      if (numChars == 0 || numChars >= size)

-        return SZ_ERROR_FAIL;

-      buf->data[numChars] = 0;

+      buf->data[0] = 0;

+      if (len != 0)

+      {

+        char defaultChar = '_';

+        BOOL defUsed;

+        unsigned numChars = 0;

+        numChars = WideCharToMultiByte(codePage, 0, s, len, (char *)buf->data, size, &defaultChar, &defUsed);

+        if (numChars == 0 || numChars >= size)

+          return SZ_ERROR_FAIL;

+        buf->data[numChars] = 0;

+      }

       return SZ_OK;

     }

   }

   #else

-  fileMode = fileMode;

   return Utf16_To_Utf8Buf(buf, s, len);

   #endif

 }

 

+#ifdef _WIN32

+  #ifndef USE_WINDOWS_FILE

+    static UINT g_FileCodePage = CP_ACP;

+  #endif

+  #define MY_FILE_CODE_PAGE_PARAM ,g_FileCodePage

+#else

+  #define MY_FILE_CODE_PAGE_PARAM

+#endif

+

 static WRes MyCreateDir(const UInt16 *name)

 {

   #ifdef USE_WINDOWS_FILE

@@ -142,7 +155,7 @@ static WRes MyCreateDir(const UInt16 *name)
   CBuf buf;

   WRes res;

   Buf_Init(&buf);

-  RINOK(Utf16_To_Char(&buf, name, 1));

+  RINOK(Utf16_To_Char(&buf, name MY_FILE_CODE_PAGE_PARAM));

 

   res =

   #ifdef _WIN32

@@ -165,7 +178,7 @@ static WRes OutFile_OpenUtf16(CSzFile *p, const UInt16 *name)
   CBuf buf;

   WRes res;

   Buf_Init(&buf);

-  RINOK(Utf16_To_Char(&buf, name, 1));

+  RINOK(Utf16_To_Char(&buf, name MY_FILE_CODE_PAGE_PARAM));

   res = OutFile_Open(p, (const char *)buf.data);

   Buf_Free(&buf, &g_Alloc);

   return res;

@@ -177,7 +190,11 @@ static SRes PrintString(const UInt16 *s)
   CBuf buf;

   SRes res;

   Buf_Init(&buf);

-  res = Utf16_To_Char(&buf, s, 0);

+  res = Utf16_To_Char(&buf, s

+      #ifdef _WIN32

+      , CP_OEMCP

+      #endif

+      );

   if (res == SZ_OK)

     fputs((const char *)buf.data, stdout);

   Buf_Free(&buf, &g_Alloc);

@@ -216,17 +233,24 @@ static char *UIntToStr(char *s, unsigned value, int numDigits)
   return s;

 }

 

+static void UIntToStr_2(char *s, unsigned value)

+{

+  s[0] = (char)('0' + (value / 10));

+  s[1] = (char)('0' + (value % 10));

+}

+

 #define PERIOD_4 (4 * 365 + 1)

 #define PERIOD_100 (PERIOD_4 * 25 - 1)

 #define PERIOD_400 (PERIOD_100 * 4 + 1)

 

-static void ConvertFileTimeToString(const CNtfsFileTime *ft, char *s)

+static void ConvertFileTimeToString(const CNtfsFileTime *nt, char *s)

 {

-  unsigned year, mon, day, hour, min, sec;

-  UInt64 v64 = (ft->Low | ((UInt64)ft->High << 32)) / 10000000;

+  unsigned year, mon, hour, min, sec;

   Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

   unsigned t;

   UInt32 v;

+  UInt64 v64 = nt->Low | ((UInt64)nt->High << 32);

+  v64 /= 10000000;

   sec = (unsigned)(v64 % 60); v64 /= 60;

   min = (unsigned)(v64 % 60); v64 /= 60;

   hour = (unsigned)(v64 % 24); v64 /= 24;

@@ -242,36 +266,34 @@ static void ConvertFileTimeToString(const CNtfsFileTime *ft, char *s)
 

   if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))

     ms[1] = 29;

-  for (mon = 1; mon <= 12; mon++)

+  for (mon = 0;; mon++)

   {

-    unsigned s = ms[mon - 1];

+    unsigned s = ms[mon];

     if (v < s)

       break;

     v -= s;

   }

-  day = (unsigned)v + 1;

   s = UIntToStr(s, year, 4); *s++ = '-';

-  s = UIntToStr(s, mon, 2);  *s++ = '-';

-  s = UIntToStr(s, day, 2);  *s++ = ' ';

-  s = UIntToStr(s, hour, 2); *s++ = ':';

-  s = UIntToStr(s, min, 2);  *s++ = ':';

-  s = UIntToStr(s, sec, 2);

+  UIntToStr_2(s, mon + 1); s[2] = '-'; s += 3;

+  UIntToStr_2(s, (unsigned)v + 1); s[2] = ' '; s += 3;

+  UIntToStr_2(s, hour); s[2] = ':'; s += 3;

+  UIntToStr_2(s, min); s[2] = ':'; s += 3;

+  UIntToStr_2(s, sec); s[2] = 0;

 }

 

-void PrintError(char *sz)

+void PrintError(const char *sz)

 {

   printf("\nERROR: %s\n", sz);

 }

 

 #ifdef USE_WINDOWS_FILE

-#define kEmptyAttribChar '.'

 static void GetAttribString(UInt32 wa, Bool isDir, char *s)

 {

-  s[0] = (char)(((wa & FILE_ATTRIBUTE_DIRECTORY) != 0 || isDir) ? 'D' : kEmptyAttribChar);

-  s[1] = (char)(((wa & FILE_ATTRIBUTE_READONLY) != 0) ? 'R': kEmptyAttribChar);

-  s[2] = (char)(((wa & FILE_ATTRIBUTE_HIDDEN) != 0) ? 'H': kEmptyAttribChar);

-  s[3] = (char)(((wa & FILE_ATTRIBUTE_SYSTEM) != 0) ? 'S': kEmptyAttribChar);

-  s[4] = (char)(((wa & FILE_ATTRIBUTE_ARCHIVE) != 0) ? 'A': kEmptyAttribChar);

+  s[0] = (char)(((wa & FILE_ATTRIBUTE_DIRECTORY) != 0 || isDir) ? 'D' : '.');

+  s[1] = (char)(((wa & FILE_ATTRIBUTE_READONLY ) != 0) ? 'R': '.');

+  s[2] = (char)(((wa & FILE_ATTRIBUTE_HIDDEN   ) != 0) ? 'H': '.');

+  s[3] = (char)(((wa & FILE_ATTRIBUTE_SYSTEM   ) != 0) ? 'S': '.');

+  s[4] = (char)(((wa & FILE_ATTRIBUTE_ARCHIVE  ) != 0) ? 'A': '.');

   s[5] = '\0';

 }

 #else

@@ -281,6 +303,8 @@ static void GetAttribString(UInt32, Bool, char *s)
 }

 #endif

 

+// #define NUM_PARENTS_MAX 128

+

 int MY_CDECL main(int numargs, char *args[])

 {

   CFileInStream archiveStream;

@@ -291,6 +315,7 @@ int MY_CDECL main(int numargs, char *args[])
   ISzAlloc allocTempImp;

   UInt16 *temp = NULL;

   size_t tempSize = 0;

+  // UInt32 parents[NUM_PARENTS_MAX];

 

   printf("\n7z ANSI-C Decoder " MY_VERSION_COPYRIGHT_DATE "\n\n");

   if (numargs == 1)

@@ -310,13 +335,21 @@ int MY_CDECL main(int numargs, char *args[])
     return 1;

   }

 

+  #if defined(_WIN32) && !defined(USE_WINDOWS_FILE) && !defined(UNDER_CE)

+  g_FileCodePage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

+  #endif

+

   allocImp.Alloc = SzAlloc;

   allocImp.Free = SzFree;

 

   allocTempImp.Alloc = SzAllocTemp;

   allocTempImp.Free = SzFreeTemp;

 

+  #ifdef UNDER_CE

+  if (InFile_OpenW(&archiveStream.file, L"\test.7z"))

+  #else

   if (InFile_Open(&archiveStream.file, args[2]))

+  #endif

   {

     PrintError("can not open input file");

     return 1;

@@ -335,11 +368,11 @@ int MY_CDECL main(int numargs, char *args[])
   if (res == SZ_OK)

   {

     char *command = args[1];

-    int listCommand = 0, testCommand = 0, extractCommand = 0, fullPaths = 0;

+    int listCommand = 0, testCommand = 0, fullPaths = 0;

     if (strcmp(command, "l") == 0) listCommand = 1;

     else if (strcmp(command, "t") == 0) testCommand = 1;

-    else if (strcmp(command, "e") == 0) extractCommand = 1;

-    else if (strcmp(command, "x") == 0) { extractCommand = 1; fullPaths = 1; }

+    else if (strcmp(command, "e") == 0) { }

+    else if (strcmp(command, "x") == 0) { fullPaths = 1; }

     else

     {

       PrintError("incorrect command");

@@ -358,22 +391,24 @@ int MY_CDECL main(int numargs, char *args[])
       Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */

       size_t outBufferSize = 0;  /* it can have any value before first call (if outBuffer = 0) */

 

-      for (i = 0; i < db.db.NumFiles; i++)

+      for (i = 0; i < db.NumFiles; i++)

       {

         size_t offset = 0;

         size_t outSizeProcessed = 0;

-        const CSzFileItem *f = db.db.Files + i;

+        // const CSzFileItem *f = db.Files + i;

         size_t len;

-        if (listCommand == 0 && f->IsDir && !fullPaths)

+        int isDir = SzArEx_IsDir(&db, i);

+        if (listCommand == 0 && isDir && !fullPaths)

           continue;

         len = SzArEx_GetFileNameUtf16(&db, i, NULL);

+        // len = SzArEx_GetFullNameLen(&db, i);

 

         if (len > tempSize)

         {

           SzFree(NULL, temp);

           tempSize = len;

           temp = (UInt16 *)SzAlloc(NULL, tempSize * sizeof(temp[0]));

-          if (temp == 0)

+          if (!temp)

           {

             res = SZ_ERROR_MEM;

             break;

@@ -381,15 +416,25 @@ int MY_CDECL main(int numargs, char *args[])
         }

 

         SzArEx_GetFileNameUtf16(&db, i, temp);

+        /*

+        if (SzArEx_GetFullNameUtf16_Back(&db, i, temp + len) != temp)

+        {

+          res = SZ_ERROR_FAIL;

+          break;

+        }

+        */

+

         if (listCommand)

         {

           char attr[8], s[32], t[32];

+          UInt64 fileSize;

 

-          GetAttribString(f->AttribDefined ? f->Attrib : 0, f->IsDir, attr);

+          GetAttribString(SzBitWithVals_Check(&db.Attribs, i) ? db.Attribs.Vals[i] : 0, isDir, attr);

 

-          UInt64ToStr(f->Size, s);

-          if (f->MTimeDefined)

-            ConvertFileTimeToString(&f->MTime, t);

+          fileSize = SzArEx_GetFileSize(&db, i);

+          UInt64ToStr(fileSize, s);

+          if (SzBitWithVals_Check(&db.MTime, i))

+            ConvertFileTimeToString(&db.MTime.Vals[i], t);

           else

           {

             size_t j;

@@ -402,7 +447,7 @@ int MY_CDECL main(int numargs, char *args[])
           res = PrintString(temp);

           if (res != SZ_OK)

             break;

-          if (f->IsDir)

+          if (isDir)

             printf("/");

           printf("\n");

           continue;

@@ -414,7 +459,7 @@ int MY_CDECL main(int numargs, char *args[])
         res = PrintString(temp);

         if (res != SZ_OK)

           break;

-        if (f->IsDir)

+        if (isDir)

           printf("/");

         else

         {

@@ -445,7 +490,7 @@ int MY_CDECL main(int numargs, char *args[])
                 destPath = name + j + 1;

             }

     

-          if (f->IsDir)

+          if (isDir)

           {

             MyCreateDir(destPath);

             printf("\n");

@@ -471,8 +516,8 @@ int MY_CDECL main(int numargs, char *args[])
             break;

           }

           #ifdef USE_WINDOWS_FILE

-          if (f->AttribDefined)

-            SetFileAttributesW(destPath, f->Attrib);

+          if (SzBitWithVals_Check(&db.Attribs, i))

+            SetFileAttributesW(destPath, db.Attribs.Vals[i]);

           #endif

         }

         printf("\n");

diff --git a/C/Util/7z/Precomp.c b/C/Util/7z/Precomp.c
new file mode 100644
index 0000000..34b60f8
--- /dev/null
+++ b/C/Util/7z/Precomp.c
@@ -0,0 +1,4 @@
+/* Precomp.c -- StdAfx

+2013-01-21 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

diff --git a/C/Util/7z/Precomp.h b/C/Util/7z/Precomp.h
new file mode 100644
index 0000000..9f398d0
--- /dev/null
+++ b/C/Util/7z/Precomp.h
@@ -0,0 +1,10 @@
+/* Precomp.h -- StdAfx

+2013-06-16 : Igor Pavlov : Public domain */

+

+#ifndef __7Z_PRECOMP_H

+#define __7Z_PRECOMP_H

+

+#include "../../Compiler.h"

+#include "../../7zTypes.h"

+

+#endif

diff --git a/C/Util/7z/makefile b/C/Util/7z/makefile
index 3b85364..08e6f68 100755..100644
--- a/C/Util/7z/makefile
+++ b/C/Util/7z/makefile
@@ -1,4 +1,4 @@
-MY_STATIC_LINK=1

+# MY_STATIC_LINK=1

 CFLAGS = $(CFLAGS) -D_7ZIP_PPMD_SUPPPORT

 

 PROG = 7zDec.exe

@@ -6,12 +6,11 @@ PROG = 7zDec.exe
 C_OBJS = \

   $O\7zAlloc.obj \

   $O\7zBuf.obj \

-  $O\7zBuf2.obj \

   $O\7zCrc.obj \

   $O\7zCrcOpt.obj \

   $O\7zFile.obj \

   $O\7zDec.obj \

-  $O\7zIn.obj \

+  $O\7zArcIn.obj \

   $O\7zStream.obj \

   $O\Bcj2.obj \

   $O\Bra.obj \

@@ -26,12 +25,15 @@ C_OBJS = \
   $O\7zMain.obj \

 

 OBJS = \

+  $O\Precomp.obj \

   $(7Z_OBJS) \

   $(C_OBJS) \

 

 !include "../../../CPP/Build.mak"

 

 $(7Z_OBJS): $(*B).c

-	$(COMPL_O1)

+	$(CCOMPL_USE)

 $(C_OBJS): ../../$(*B).c

-	$(COMPL_O2)

+	$(CCOMPL_USE)

+$O\Precomp.obj: Precomp.c

+	$(CCOMPL_PCH)

diff --git a/C/Util/7z/makefile.gcc b/C/Util/7z/makefile.gcc
index 2fb1576..63c59ca 100755..100644
--- a/C/Util/7z/makefile.gcc
+++ b/C/Util/7z/makefile.gcc
@@ -4,7 +4,7 @@ LIB =
 RM = rm -f

 CFLAGS = -c -O2 -Wall

 

-OBJS = 7zMain.o 7zAlloc.o 7zBuf.o 7zBuf2.o 7zCrc.o 7zCrcOpt.o 7zDec.o 7zIn.o CpuArch.o LzmaDec.o Lzma2Dec.o Bra.o Bra86.o Bcj2.o Ppmd7.o Ppmd7Dec.o 7zFile.o 7zStream.o

+OBJS = 7zMain.o 7zAlloc.o 7zArcIn.o 7zBuf.o 7zBuf2.o 7zCrc.o 7zCrcOpt.o 7zDec.o CpuArch.o LzmaDec.o Lzma2Dec.o Bra.o Bra86.o Bcj2.o Ppmd7.o Ppmd7Dec.o 7zFile.o 7zStream.o

 

 all: $(PROG)

 

@@ -14,9 +14,12 @@ $(PROG): $(OBJS)
 7zMain.o: 7zMain.c

 	$(CXX) $(CFLAGS) 7zMain.c

 

-7zAlloc.o: 7zAlloc.c

+7zAlloc.o: ../../7zAlloc.c

 	$(CXX) $(CFLAGS) ../../7zAlloc.c

 

+7zArcIn.o: ../../7zArcIn.c

+	$(CXX) $(CFLAGS) ../../7zArcIn.c

+

 7zBuf.o: ../../7zBuf.c

 	$(CXX) $(CFLAGS) ../../7zBuf.c

 

@@ -32,9 +35,6 @@ $(PROG): $(OBJS)
 7zDec.o: ../../7zDec.c

 	$(CXX) $(CFLAGS) -D_7ZIP_PPMD_SUPPPORT ../../7zDec.c

 

-7zIn.o: ../../7zIn.c

-	$(CXX) $(CFLAGS) ../../7zIn.c

-

 CpuArch.o: ../../CpuArch.c

 	$(CXX) $(CFLAGS) ../../CpuArch.c

 

diff --git a/C/Util/Lzma/LzmaUtil.c b/C/Util/Lzma/LzmaUtil.c
index f8de4a2..ee659ba 100755..100644
--- a/C/Util/Lzma/LzmaUtil.c
+++ b/C/Util/Lzma/LzmaUtil.c
@@ -1,7 +1,7 @@
 /* LzmaUtil.c -- Test application for LZMA compression

-2010-09-20 : Igor Pavlov : Public domain */

+2014-12-31 : Igor Pavlov : Public domain */

 

-#define _CRT_SECURE_NO_WARNINGS

+#include "../../Precomp.h"

 

 #include <stdio.h>

 #include <stdlib.h>

@@ -92,7 +92,7 @@ static SRes Decode2(CLzmaDec *state, ISeqOutStream *outStream, ISeqInStream *inS
         

       outPos = 0;

       

-      if (res != SZ_OK || thereIsSize && unpackSize == 0)

+      if (res != SZ_OK || (thereIsSize && unpackSize == 0))

         return res;

       

       if (inProcessed == 0 && outProcessed == 0)

diff --git a/C/Util/Lzma/LzmaUtil.dsp b/C/Util/Lzma/LzmaUtil.dsp
index 4815511..df1f0cb 100755..100644
--- a/C/Util/Lzma/LzmaUtil.dsp
+++ b/C/Util/Lzma/LzmaUtil.dsp
@@ -42,7 +42,7 @@ RSC=rc.exe
 # PROP Ignore_Export_Lib 0

 # PROP Target_Dir ""

 # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

-# ADD CPP /nologo /MT /W3 /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c

+# ADD CPP /nologo /MT /W4 /WX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c

 # SUBTRACT CPP /YX

 # ADD BASE RSC /l 0x419 /d "NDEBUG"

 # ADD RSC /l 0x419 /d "NDEBUG"

@@ -67,7 +67,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0

 # PROP Target_Dir ""

 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c

-# ADD CPP /nologo /MTd /W3 /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c

+# ADD CPP /nologo /MTd /W4 /WX /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c

 # SUBTRACT CPP /YX

 # ADD BASE RSC /l 0x419 /d "_DEBUG"

 # ADD RSC /l 0x419 /d "_DEBUG"

diff --git a/C/Util/Lzma/LzmaUtil.dsw b/C/Util/Lzma/LzmaUtil.dsw
index f435487..f435487 100755..100644
--- a/C/Util/Lzma/LzmaUtil.dsw
+++ b/C/Util/Lzma/LzmaUtil.dsw
diff --git a/C/Util/Lzma/makefile b/C/Util/Lzma/makefile
index e99e098..3b825f2 100755..100644
--- a/C/Util/Lzma/makefile
+++ b/C/Util/Lzma/makefile
@@ -1,4 +1,4 @@
-MY_STATIC_LINK=1

+# MY_STATIC_LINK=1

 PROG = LZMAc.exe

 

 CFLAGS = $(CFLAGS) \

diff --git a/C/Util/Lzma/makefile.gcc b/C/Util/Lzma/makefile.gcc
index 12a72bb..12a72bb 100755..100644
--- a/C/Util/Lzma/makefile.gcc
+++ b/C/Util/Lzma/makefile.gcc
diff --git a/C/Util/LzmaLib/LzmaLib.def b/C/Util/LzmaLib/LzmaLib.def
index 43b9597..43b9597 100755..100644
--- a/C/Util/LzmaLib/LzmaLib.def
+++ b/C/Util/LzmaLib/LzmaLib.def
diff --git a/C/Util/LzmaLib/LzmaLib.dsp b/C/Util/LzmaLib/LzmaLib.dsp
index bf52b63..0d4c981 100755..100644
--- a/C/Util/LzmaLib/LzmaLib.dsp
+++ b/C/Util/LzmaLib/LzmaLib.dsp
@@ -104,6 +104,10 @@ SOURCE=.\LzmaLibExports.c
 # End Group

 # Begin Source File

 

+SOURCE=..\..\7zTypes.h

+# End Source File

+# Begin Source File

+

 SOURCE=..\..\Alloc.c

 # End Source File

 # Begin Source File

@@ -170,9 +174,5 @@ SOURCE=..\..\Threads.c
 

 SOURCE=..\..\Threads.h

 # End Source File

-# Begin Source File

-

-SOURCE=..\..\Types.h

-# End Source File

 # End Target

 # End Project

diff --git a/C/Util/LzmaLib/LzmaLib.dsw b/C/Util/LzmaLib/LzmaLib.dsw
index f6c5559..f6c5559 100755..100644
--- a/C/Util/LzmaLib/LzmaLib.dsw
+++ b/C/Util/LzmaLib/LzmaLib.dsw
diff --git a/C/Util/LzmaLib/LzmaLibExports.c b/C/Util/LzmaLib/LzmaLibExports.c
index 7434536..7434536 100755..100644
--- a/C/Util/LzmaLib/LzmaLibExports.c
+++ b/C/Util/LzmaLib/LzmaLibExports.c
diff --git a/C/Util/LzmaLib/makefile b/C/Util/LzmaLib/makefile
index e0f3114..e0f3114 100755..100644
--- a/C/Util/LzmaLib/makefile
+++ b/C/Util/LzmaLib/makefile
diff --git a/C/Util/LzmaLib/resource.rc b/C/Util/LzmaLib/resource.rc
index cb62ed9..d95e3f3 100755..100644
--- a/C/Util/LzmaLib/resource.rc
+++ b/C/Util/LzmaLib/resource.rc
@@ -1,4 +1,3 @@
-#include "../../../CPP/7zip/MyVersionInfo.rc"

+#include "../../7zVersion.rc"

 

 MY_VERSION_INFO_DLL("LZMA library", "LZMA")

-

diff --git a/C/Util/SfxSetup/Precomp.c b/C/Util/SfxSetup/Precomp.c
new file mode 100644
index 0000000..34b60f8
--- /dev/null
+++ b/C/Util/SfxSetup/Precomp.c
@@ -0,0 +1,4 @@
+/* Precomp.c -- StdAfx

+2013-01-21 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

diff --git a/C/Util/SfxSetup/Precomp.h b/C/Util/SfxSetup/Precomp.h
new file mode 100644
index 0000000..9f398d0
--- /dev/null
+++ b/C/Util/SfxSetup/Precomp.h
@@ -0,0 +1,10 @@
+/* Precomp.h -- StdAfx

+2013-06-16 : Igor Pavlov : Public domain */

+

+#ifndef __7Z_PRECOMP_H

+#define __7Z_PRECOMP_H

+

+#include "../../Compiler.h"

+#include "../../7zTypes.h"

+

+#endif

diff --git a/C/Util/SfxSetup/SfxSetup.c b/C/Util/SfxSetup/SfxSetup.c
index d4eb5c4..5714e43 100755..100644
--- a/C/Util/SfxSetup/SfxSetup.c
+++ b/C/Util/SfxSetup/SfxSetup.c
@@ -1,5 +1,7 @@
 /* SfxSetup.c - 7z SFX Setup

-2010-11-11 : Igor Pavlov : Public domain */

+2014-12-07 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #ifndef UNICODE

 #define UNICODE

@@ -19,27 +21,28 @@
 #include "../../7zFile.h"

 #include "../../CpuArch.h"

 

-#define k_EXE_ExtIndex 1

+#define k_EXE_ExtIndex 2

 

 static const char *kExts[] =

 {

-  "bat",

-  "exe",

-  "inf",

-  "msi",

+    "bat"

+  , "cmd"

+  , "exe"

+  , "inf"

+  , "msi"

   #ifdef UNDER_CE

-  "cab",

+  , "cab"

   #endif

-  "html",

-  "htm"

+  , "html"

+  , "htm"

 };

 

 static const char *kNames[] =

 {

-  "setup",

-  "install",

-  "run",

-  "start"

+    "setup"

+  , "install"

+  , "run"

+  , "start"

 };

 

 static unsigned FindExt(const wchar_t *s, unsigned *extLen)

@@ -128,26 +131,21 @@ static Bool FindSignature(CSzFile *stream, UInt64 *resPos)
   *resPos = 0;

   for (;;)

   {

-    size_t numTests, pos;

+    size_t processed, pos;

     if (*resPos > kSignatureSearchLimit)

       return False;

-    

-    do

-    {

-      size_t processed = kBufferSize - numPrevBytes;

-      if (File_Read(stream, buf + numPrevBytes, &processed) != 0)

-        return False;

-      if (processed == 0)

-        return False;

-      numPrevBytes += processed;

-    }

-    while (numPrevBytes <= k7zStartHeaderSize);

-    

-    numTests = numPrevBytes - k7zStartHeaderSize;

-    for (pos = 0; pos < numTests; pos++)

+    processed = kBufferSize - numPrevBytes;

+    if (File_Read(stream, buf + numPrevBytes, &processed) != 0)

+      return False;

+    processed += numPrevBytes;

+    if (processed < k7zStartHeaderSize ||

+        (processed == k7zStartHeaderSize && numPrevBytes != 0))

+      return False;

+    processed -= k7zStartHeaderSize;

+    for (pos = 0; pos <= processed; pos++)

     {

-      for (; buf[pos] != '7' && pos < numTests; pos++);

-      if (pos == numTests)

+      for (; buf[pos] != '7' && pos <= processed; pos++);

+      if (pos > processed)

         break;

       if (memcmp(buf + pos, k7zSignature, k7zSignatureSize) == 0)

         if (CrcCalc(buf + pos + 12, 20) == GetUi32(buf + pos + 8))

@@ -156,9 +154,9 @@ static Bool FindSignature(CSzFile *stream, UInt64 *resPos)
           return True;

         }

     }

-    *resPos += numTests;

-    numPrevBytes -= numTests;

-    memmove(buf, buf + numTests, numPrevBytes);

+    *resPos += processed;

+    numPrevBytes = k7zStartHeaderSize;

+    memmove(buf, buf + processed, k7zStartHeaderSize);

   }

 }

 

@@ -192,7 +190,7 @@ static WRes RemoveDirWithSubItems(WCHAR *path)
       wcscpy(path + len, fd.cFileName);

       if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)

       {

-        wcscat(path, L"\\");

+        wcscat(path, WSTRING_PATH_SEPARATOR);

         res = RemoveDirWithSubItems(path);

       }

       else

@@ -242,6 +240,9 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
   ISzAlloc allocTempImp;

   WCHAR sfxPath[MAX_PATH + 2];

   WCHAR path[MAX_PATH * 3 + 2];

+  #ifndef UNDER_CE

+  WCHAR workCurDir[MAX_PATH + 32];

+  #endif

   size_t pathLen;

   DWORD winRes;

   const wchar_t *cmdLineParams;

@@ -296,6 +297,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
       return 1;

     pathLen = wcslen(path);

     d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();

+    

     for (i = 0;; i++, d += GetTickCount())

     {

       if (i >= 100)

@@ -322,7 +324,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
         continue;

       if (CreateDirectoryW(path, NULL))

       {

-        wcscat(path, L"\\");

+        wcscat(path, WSTRING_PATH_SEPARATOR);

         pathLen = wcslen(path);

         break;

       }

@@ -332,6 +334,10 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
         break;

       }

     }

+    

+    #ifndef UNDER_CE

+    wcscpy(workCurDir, path);

+    #endif

     if (res != SZ_OK)

       errorMessage = "Can't create temp folder";

   }

@@ -371,6 +377,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
   {

     res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);

   }

+  

   if (res == SZ_OK)

   {

     UInt32 executeFileIndex = (UInt32)(Int32)-1;

@@ -380,11 +387,10 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
     Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */

     size_t outBufferSize = 0;  /* it can have any value before first call (if outBuffer = 0) */

     

-    for (i = 0; i < db.db.NumFiles; i++)

+    for (i = 0; i < db.NumFiles; i++)

     {

       size_t offset = 0;

       size_t outSizeProcessed = 0;

-      const CSzFileItem *f = db.db.Files + i;

       size_t len;

       WCHAR *temp;

       len = SzArEx_GetFileNameUtf16(&db, i, NULL);

@@ -422,7 +428,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
           }

         }

 

-        if (f->IsDir)

+        if (SzArEx_IsDir(&db, i))

         {

           MyCreateDir(path);

           continue;

@@ -457,6 +463,7 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
             break;

           }

         }

+  

         processedSize = outSizeProcessed;

         if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)

         {

@@ -465,11 +472,12 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
         }

         

         #ifdef USE_WINDOWS_FILE

-        if (f->MTimeDefined)

+        if (SzBitWithVals_Check(&db.MTime, i))

         {

+          const CNtfsFileTime *t = db.MTime.Vals + i;

           FILETIME mTime;

-          mTime.dwLowDateTime = f->MTime.Low;

-          mTime.dwHighDateTime = f->MTime.High;

+          mTime.dwLowDateTime = t->Low;

+          mTime.dwHighDateTime = t->High;

           SetFileTime(outFile.handle, NULL, NULL, &mTime);

         }

         #endif

@@ -485,8 +493,8 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
           }

         }

         #ifdef USE_WINDOWS_FILE

-        if (f->AttribDefined)

-          SetFileAttributesW(path, f->Attrib);

+        if (SzBitWithVals_Check(&db.Attribs, i))

+          SetFileAttributesW(path, db.Attribs.Vals[i]);

         #endif

       }

     }

@@ -517,6 +525,18 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
   if (res == SZ_OK)

   {

     HANDLE hProcess = 0;

+    

+    #ifndef UNDER_CE

+    WCHAR oldCurDir[MAX_PATH + 2];

+    oldCurDir[0] = 0;

+    {

+      DWORD needLen = GetCurrentDirectory(MAX_PATH + 1, oldCurDir);

+      if (needLen == 0 || needLen > MAX_PATH)

+        oldCurDir[0] = 0;

+      SetCurrentDirectory(workCurDir);

+    }

+    #endif

+    

     if (useShellExecute)

     {

       SHELLEXECUTEINFO ei;

@@ -560,11 +580,16 @@ int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
         hProcess = pi.hProcess;

       }

     }

+    

     if (hProcess != 0)

     {

       WaitForSingleObject(hProcess, INFINITE);

       CloseHandle(hProcess);

     }

+    

+    #ifndef UNDER_CE

+    SetCurrentDirectory(oldCurDir);

+    #endif

   }

 

   path[pathLen] = L'\0';

diff --git a/C/Util/SfxSetup/SfxSetup.dsp b/C/Util/SfxSetup/SfxSetup.dsp
index 10814a5..1d5fdd8 100755..100644
--- a/C/Util/SfxSetup/SfxSetup.dsp
+++ b/C/Util/SfxSetup/SfxSetup.dsp
@@ -42,7 +42,7 @@ RSC=rc.exe
 # PROP Intermediate_Dir "Release"

 # PROP Target_Dir ""

 # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /c

-# ADD CPP /nologo /W3 /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /YX /FD /c

+# ADD CPP /nologo /W4 /WX /GX /O2 /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /c

 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32

 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32

 # ADD BASE RSC /l 0x419 /d "NDEBUG"

@@ -68,7 +68,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0

 # PROP Target_Dir ""

 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c

-# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /YX /FD /GZ /c

+# ADD CPP /nologo /W4 /WX /Gm /GX /ZI /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_UNICODE" /D "UNICODE" /Yu"Precomp.h" /FD /GZ /c

 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32

 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32

 # ADD BASE RSC /l 0x419 /d "_DEBUG"

@@ -103,6 +103,10 @@ SOURCE=..\..\7zAlloc.h
 # End Source File

 # Begin Source File

 

+SOURCE=..\..\7zArcIn.c

+# End Source File

+# Begin Source File

+

 SOURCE=..\..\7zBuf.c

 # End Source File

 # Begin Source File

@@ -135,11 +139,11 @@ SOURCE=..\..\7zFile.h
 # End Source File

 # Begin Source File

 

-SOURCE=..\..\7zIn.c

+SOURCE=..\..\7zStream.c

 # End Source File

 # Begin Source File

 

-SOURCE=..\..\7zStream.c

+SOURCE=..\..\7zTypes.h

 # End Source File

 # Begin Source File

 

@@ -185,9 +189,18 @@ SOURCE=..\..\LzmaDec.c
 

 SOURCE=..\..\LzmaDec.h

 # End Source File

+# End Group

+# Begin Group "Spec"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=.\Precomp.c

+# ADD CPP /Yc"Precomp.h"

+# End Source File

 # Begin Source File

 

-SOURCE=..\..\Types.h

+SOURCE=.\Precomp.h

 # End Source File

 # End Group

 # Begin Source File

diff --git a/C/Util/SfxSetup/SfxSetup.dsw b/C/Util/SfxSetup/SfxSetup.dsw
index 128fcdd..128fcdd 100755..100644
--- a/C/Util/SfxSetup/SfxSetup.dsw
+++ b/C/Util/SfxSetup/SfxSetup.dsw
diff --git a/C/Util/SfxSetup/makefile b/C/Util/SfxSetup/makefile
index 5d91be1..cc9878a 100755..100644
--- a/C/Util/SfxSetup/makefile
+++ b/C/Util/SfxSetup/makefile
@@ -1,16 +1,14 @@
 PROG = 7zS2.sfx

-LIBS = $(LIBS) 

-CFLAGS = $(CFLAGS) -DUNICODE -D_UNICODE

 

 C_OBJS = \

   $O\7zAlloc.obj \

+  $O\7zArcIn.obj \

   $O\7zBuf.obj \

   $O\7zBuf2.obj \

   $O\7zCrc.obj \

   $O\7zCrcOpt.obj \

   $O\7zFile.obj \

   $O\7zDec.obj \

-  $O\7zIn.obj \

   $O\7zStream.obj \

   $O\Bcj2.obj \

   $O\Bra.obj \

diff --git a/C/Util/SfxSetup/makefile_con b/C/Util/SfxSetup/makefile_con
index 3fbb6b6..f8bbb1f 100755..100644
--- a/C/Util/SfxSetup/makefile_con
+++ b/C/Util/SfxSetup/makefile_con
@@ -1,16 +1,15 @@
 PROG = 7zS2con.sfx

-LIBS = $(LIBS) 

-CFLAGS = $(CFLAGS) -DUNICODE -D_UNICODE -D_CONSOLE

+CFLAGS = $(CFLAGS) -D_CONSOLE

 

 C_OBJS = \

   $O\7zAlloc.obj \

+  $O\7zArcIn.obj \

   $O\7zBuf.obj \

   $O\7zBuf2.obj \

   $O\7zCrc.obj \

   $O\7zCrcOpt.obj \

   $O\7zFile.obj \

   $O\7zDec.obj \

-  $O\7zIn.obj \

   $O\7zStream.obj \

   $O\Bcj2.obj \

   $O\Bra.obj \

diff --git a/C/Util/SfxSetup/resource.rc b/C/Util/SfxSetup/resource.rc
index efff95e..64f4e2c 100755..100644
--- a/C/Util/SfxSetup/resource.rc
+++ b/C/Util/SfxSetup/resource.rc
@@ -1,6 +1,5 @@
-#include "../../../CPP/7zip/MyVersionInfo.rc"

+#include "../../7zVersion.rc"

 

 MY_VERSION_INFO_APP("7z Setup SFX small", "7zS2.sfx")

 

 1  ICON "setup.ico"

-

diff --git a/C/Util/SfxSetup/setup.ico b/C/Util/SfxSetup/setup.ico
index dbb6ca8..dbb6ca8 100755..100644
--- a/C/Util/SfxSetup/setup.ico
+++ b/C/Util/SfxSetup/setup.ico
diff --git a/C/Xz.c b/C/Xz.c
index 0bdf047..f7b5c24 100755..100644
--- a/C/Xz.c
+++ b/C/Xz.c
@@ -1,6 +1,8 @@
 /* Xz.c - Xz

 2009-04-15 : Igor Pavlov : Public domain */

 

+#include "Precomp.h"

+

 #include "7zCrc.h"

 #include "CpuArch.h"

 #include "Xz.h"

diff --git a/C/Xz.h b/C/Xz.h
index d307963..2512fd1 100755..100644
--- a/C/Xz.h
+++ b/C/Xz.h
@@ -1,5 +1,5 @@
 /* Xz.h - Xz interface

-2010-09-17 : Igor Pavlov : Public domain */

+2014-12-30 : Igor Pavlov : Public domain */

 

 #ifndef __XZ_H

 #define __XZ_H

@@ -209,7 +209,9 @@ typedef struct
   UInt64 indexPos;

   UInt64 padSize;

 

-  UInt64 numStreams;

+  UInt64 numStartedStreams;

+  UInt64 numFinishedStreams;

+  UInt64 numTotalBlocks;

 

   UInt32 crc;

   CMixCoder decoder;

@@ -220,33 +222,54 @@ typedef struct
   Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];

 } CXzUnpacker;

 

-SRes XzUnpacker_Create(CXzUnpacker *p, ISzAlloc *alloc);

+void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc);

+void XzUnpacker_Init(CXzUnpacker *p);

 void XzUnpacker_Free(CXzUnpacker *p);

 

 /*

 finishMode:

   It has meaning only if the decoding reaches output limit (*destLen).

-  LZMA_FINISH_ANY - use smallest number of input bytes

-  LZMA_FINISH_END - read EndOfStream marker after decoding

+  CODER_FINISH_ANY - use smallest number of input bytes

+  CODER_FINISH_END - read EndOfStream marker after decoding

 

 Returns:

   SZ_OK

     status:

-      LZMA_STATUS_FINISHED_WITH_MARK

-      LZMA_STATUS_NOT_FINISHED

-  SZ_ERROR_DATA - Data error

+      CODER_STATUS_NOT_FINISHED,

+      CODER_STATUS_NEEDS_MORE_INPUT - maybe there are more xz streams,

+                                      call XzUnpacker_IsStreamWasFinished to check that current stream was finished

   SZ_ERROR_MEM  - Memory allocation error

-  SZ_ERROR_UNSUPPORTED - Unsupported properties

-  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).

+  SZ_ERROR_DATA - Data error

+  SZ_ERROR_UNSUPPORTED - Unsupported method or method properties

+  SZ_ERROR_CRC  - CRC error

+  // SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).

+

+  SZ_ERROR_NO_ARCHIVE - the error with xz Stream Header with one of the following reasons:

+     - xz Stream Signature failure

+     - CRC32 of xz Stream Header is failed

+     - The size of Stream padding is not multiple of four bytes.

+    It's possible to get that error, if xz stream was finished and the stream

+    contains some another data. In that case you can call XzUnpacker_GetExtraSize()

+    function to get real size of xz stream.

 */

 

 

 SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,

-    const Byte *src, SizeT *srcLen, /* int srcWasFinished, */ int finishMode,

+    const Byte *src, SizeT *srcLen, ECoderFinishMode finishMode,

     ECoderStatus *status);

 

 Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p);

 

+/*

+Call XzUnpacker_GetExtraSize after XzUnpacker_Code function to detect real size of

+xz stream in two cases:

+XzUnpacker_Code() returns:

+  res == SZ_OK && status == CODER_STATUS_NEEDS_MORE_INPUT

+  res == SZ_ERROR_NO_ARCHIVE

+*/

+

+UInt64 XzUnpacker_GetExtraSize(CXzUnpacker *p);

+

 EXTERN_C_END

 

 #endif

diff --git a/C/XzCrc64.c b/C/XzCrc64.c
index f688b07..667e41b 100755..100644
--- a/C/XzCrc64.c
+++ b/C/XzCrc64.c
@@ -1,33 +1,90 @@
 /* XzCrc64.c -- CRC64 calculation

-2010-04-16 : Igor Pavlov : Public domain */

+2011-06-28 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include "XzCrc64.h"

+#include "CpuArch.h"

 

 #define kCrc64Poly UINT64_CONST(0xC96C5795D7870F42)

-UInt64 g_Crc64Table[256];

 

-void MY_FAST_CALL Crc64GenerateTable(void)

+#ifdef MY_CPU_LE

+  #define CRC_NUM_TABLES 4

+#else

+  #define CRC_NUM_TABLES 5

+  #define CRC_UINT64_SWAP(v) \

+  ((v >> 56) | \

+  ((v >> 40) & ((UInt64)0xFF <<  8)) | \

+  ((v >> 24) & ((UInt64)0xFF << 16)) | \

+  ((v >>  8) & ((UInt64)0xFF << 24)) | \

+  ((v <<  8) & ((UInt64)0xFF << 32)) | \

+  ((v << 24) & ((UInt64)0xFF << 40)) | \

+  ((v << 40) & ((UInt64)0xFF << 48)) | \

+   (v << 56))

+  UInt64 MY_FAST_CALL XzCrc64UpdateT1_BeT4(UInt64 v, const void *data, size_t size, const UInt64 *table);

+#endif

+

+#ifndef MY_CPU_BE

+  UInt64 MY_FAST_CALL XzCrc64UpdateT4(UInt64 v, const void *data, size_t size, const UInt64 *table);

+#endif

+

+typedef UInt64 (MY_FAST_CALL *CRC_FUNC)(UInt64 v, const void *data, size_t size, const UInt64 *table);

+

+static CRC_FUNC g_Crc64Update;

+UInt64 g_Crc64Table[256 * CRC_NUM_TABLES];

+

+UInt64 MY_FAST_CALL Crc64Update(UInt64 v, const void *data, size_t size)

+{

+  return g_Crc64Update(v, data, size, g_Crc64Table);

+}

+

+UInt64 MY_FAST_CALL Crc64Calc(const void *data, size_t size)

+{

+  return g_Crc64Update(CRC64_INIT_VAL, data, size, g_Crc64Table) ^ CRC64_INIT_VAL;

+}

+

+void MY_FAST_CALL Crc64GenerateTable()

 {

   UInt32 i;

   for (i = 0; i < 256; i++)

   {

     UInt64 r = i;

-    int j;

+    unsigned j;

     for (j = 0; j < 8; j++)

-      r = (r >> 1) ^ ((UInt64)kCrc64Poly & ~((r & 1) - 1));

+      r = (r >> 1) ^ (kCrc64Poly & ~((r & 1) - 1));

     g_Crc64Table[i] = r;

   }

-}

+  for (; i < 256 * CRC_NUM_TABLES; i++)

+  {

+    UInt64 r = g_Crc64Table[i - 256];

+    g_Crc64Table[i] = g_Crc64Table[r & 0xFF] ^ (r >> 8);

+  }

+  

+  #ifdef MY_CPU_LE

 

-UInt64 MY_FAST_CALL Crc64Update(UInt64 v, const void *data, size_t size)

-{

-  const Byte *p = (const Byte *)data;

-  for (; size > 0 ; size--, p++)

-    v = CRC64_UPDATE_BYTE(v, *p);

-  return v;

-}

+  g_Crc64Update = XzCrc64UpdateT4;

 

-UInt64 MY_FAST_CALL Crc64Calc(const void *data, size_t size)

-{

-  return CRC64_GET_DIGEST(Crc64Update(CRC64_INIT_VAL, data, size));

+  

+

+

+

+

+  #else

+  {

+    #ifndef MY_CPU_BE

+    UInt32 k = 1;

+    if (*(const Byte *)&k == 1)

+      g_Crc64Update = XzCrc64UpdateT4;

+    else

+    #endif

+    {

+      for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)

+      {

+        UInt64 x = g_Crc64Table[i - 256];

+        g_Crc64Table[i] = CRC_UINT64_SWAP(x);

+      }

+      g_Crc64Update = XzCrc64UpdateT1_BeT4;

+    }

+  }

+  #endif

 }

diff --git a/C/XzCrc64.h b/C/XzCrc64.h
index 05d0d09..71b10d5 100755..100644
--- a/C/XzCrc64.h
+++ b/C/XzCrc64.h
@@ -1,12 +1,12 @@
 /* XzCrc64.h -- CRC64 calculation

-2010-04-16 : Igor Pavlov : Public domain */

+2013-01-18 : Igor Pavlov : Public domain */

 

 #ifndef __XZ_CRC64_H

 #define __XZ_CRC64_H

 

 #include <stddef.h>

 

-#include "Types.h"

+#include "7zTypes.h"

 

 EXTERN_C_BEGIN

 

diff --git a/C/XzCrc64Opt.c b/C/XzCrc64Opt.c
new file mode 100644
index 0000000..65be5cd
--- /dev/null
+++ b/C/XzCrc64Opt.c
@@ -0,0 +1,69 @@
+/* XzCrc64Opt.c -- CRC64 calculation

+2011-06-28 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

+

+#include "CpuArch.h"

+

+#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))

+

+#ifndef MY_CPU_BE

+

+UInt64 MY_FAST_CALL XzCrc64UpdateT4(UInt64 v, const void *data, size_t size, const UInt64 *table)

+{

+  const Byte *p = (const Byte *)data;

+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)

+    v = CRC_UPDATE_BYTE_2(v, *p);

+  for (; size >= 4; size -= 4, p += 4)

+  {

+    UInt32 d = (UInt32)v ^ *(const UInt32 *)p;

+    v = (v >> 32) ^

+      table[0x300 + ((d      ) & 0xFF)] ^

+      table[0x200 + ((d >>  8) & 0xFF)] ^

+      table[0x100 + ((d >> 16) & 0xFF)] ^

+      table[0x000 + ((d >> 24))];

+  }

+  for (; size > 0; size--, p++)

+    v = CRC_UPDATE_BYTE_2(v, *p);

+  return v;

+}

+

+#endif

+

+

+#ifndef MY_CPU_LE

+

+#define CRC_UINT64_SWAP(v) \

+  ((v >> 56) | \

+  ((v >> 40) & ((UInt64)0xFF <<  8)) | \

+  ((v >> 24) & ((UInt64)0xFF << 16)) | \

+  ((v >>  8) & ((UInt64)0xFF << 24)) | \

+  ((v <<  8) & ((UInt64)0xFF << 32)) | \

+  ((v << 24) & ((UInt64)0xFF << 40)) | \

+  ((v << 40) & ((UInt64)0xFF << 48)) | \

+   (v << 56))

+

+UInt64 MY_FAST_CALL XzCrc64UpdateT1_BeT4(UInt64 v, const void *data, size_t size, const UInt64 *table)

+{

+  const Byte *p = (const Byte *)data;

+  for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)

+    v = CRC_UPDATE_BYTE_2(v, *p);

+  v = CRC_UINT64_SWAP(v);

+  table += 0x100;

+  for (; size >= 4; size -= 4, p += 4)

+  {

+    UInt32 d = (UInt32)(v >> 32) ^ *(const UInt32 *)p;

+    v = (v << 32) ^

+      table[0x000 + ((d      ) & 0xFF)] ^

+      table[0x100 + ((d >>  8) & 0xFF)] ^

+      table[0x200 + ((d >> 16) & 0xFF)] ^

+      table[0x300 + ((d >> 24))];

+  }

+  table -= 0x100;

+  v = CRC_UINT64_SWAP(v);

+  for (; size > 0; size--, p++)

+    v = CRC_UPDATE_BYTE_2(v, *p);

+  return v;

+}

+

+#endif

diff --git a/C/XzDec.c b/C/XzDec.c
index 2eca1af..e23f221 100755..100644
--- a/C/XzDec.c
+++ b/C/XzDec.c
@@ -1,5 +1,7 @@
 /* XzDec.c -- Xz Decode

-2010-04-16 : Igor Pavlov : Public domain */

+2014-12-30 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 /* #define XZ_DUMP */

 

@@ -18,7 +20,8 @@
 #include "Lzma2Dec.h"

 

 #ifdef USE_SUBBLOCK

-#include "SbDec.h"

+#include "Bcj3Dec.c"

+#include "SbDec.c"

 #endif

 

 #include "Xz.h"

@@ -72,7 +75,6 @@ SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *a
 {

   CBraState *p = ((CBraState *)pp);

   alloc = alloc;

-  p->encodeMode = 0;

   p->ip = 0;

   if (p->methodId == XZ_ID_Delta)

   {

@@ -195,7 +197,7 @@ static SRes BraState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src,
   return SZ_OK;

 }

 

-SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, ISzAlloc *alloc)

+SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAlloc *alloc)

 {

   CBraState *decoder;

   if (id != XZ_ID_Delta &&

@@ -207,10 +209,11 @@ SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, ISzAlloc *alloc)
       id != XZ_ID_SPARC)

     return SZ_ERROR_UNSUPPORTED;

   p->p = 0;

-  decoder = alloc->Alloc(alloc, sizeof(CBraState));

+  decoder = (CBraState *)alloc->Alloc(alloc, sizeof(CBraState));

   if (decoder == 0)

     return SZ_ERROR_MEM;

   decoder->methodId = (UInt32)id;

+  decoder->encodeMode = encodeMode;

   p->p = decoder;

   p->Free = BraState_Free;

   p->SetProps = BraState_SetProps;

@@ -225,8 +228,8 @@ SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, ISzAlloc *alloc)
 

 static void SbState_Free(void *pp, ISzAlloc *alloc)

 {

-  CSubblockDec *p = (CSubblockDec *)pp;

-  SubblockDec_Free(p, alloc);

+  CSbDec *p = (CSbDec *)pp;

+  SbDec_Free(p);

   alloc->Free(alloc, pp);

 }

 

@@ -240,24 +243,32 @@ static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAl
 

 static void SbState_Init(void *pp)

 {

-  SubblockDec_Init((CSubblockDec *)pp);

+  SbDec_Init((CSbDec *)pp);

 }

 

 static SRes SbState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,

     int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)

 {

-  ECoderStatus status;

-  SRes res = SubblockDec_Decode((CSubblockDec *)pp, dest, destLen, src, srcLen, finishMode, &status);

+  CSbDec *p = (CSbDec *)pp;

+  SRes res;

   srcWasFinished = srcWasFinished;

-  *wasFinished = (status == LZMA_STATUS_FINISHED_WITH_MARK);

+  p->dest = dest;

+  p->destLen = *destLen;

+  p->src = src;

+  p->srcLen = *srcLen;

+  p->finish = finishMode; /* change it */

+  res = SbDec_Decode((CSbDec *)pp);

+  *destLen -= p->destLen;

+  *srcLen -= p->srcLen;

+  *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */

   return res;

 }

 

 SRes SbState_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)

 {

-  CSubblockDec *decoder;

+  CSbDec *decoder;

   p->p = 0;

-  decoder = alloc->Alloc(alloc, sizeof(CSubblockDec));

+  decoder = alloc->Alloc(alloc, sizeof(CSbDec));

   if (decoder == 0)

     return SZ_ERROR_MEM;

   p->p = decoder;

@@ -265,7 +276,8 @@ SRes SbState_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)
   p->SetProps = SbState_SetProps;

   p->Init = SbState_Init;

   p->Code = SbState_Code;

-  SubblockDec_Construct(decoder);

+  SbDec_Construct(decoder);

+  SbDec_SetAlloc(decoder, alloc);

   return SZ_OK;

 }

 #endif

@@ -295,7 +307,7 @@ static SRes Lzma2State_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *sr
 {

   ELzmaStatus status;

   /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */

-  SRes res = Lzma2Dec_DecodeToBuf((CLzma2Dec *)pp, dest, destLen, src, srcLen, finishMode, &status);

+  SRes res = Lzma2Dec_DecodeToBuf((CLzma2Dec *)pp, dest, destLen, src, srcLen, (ELzmaFinishMode)finishMode, &status);

   srcWasFinished = srcWasFinished;

   *wasFinished = (status == LZMA_STATUS_FINISHED_WITH_MARK);

   return res;

@@ -303,7 +315,7 @@ static SRes Lzma2State_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *sr
 

 static SRes Lzma2State_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)

 {

-  CLzma2Dec *decoder = alloc->Alloc(alloc, sizeof(CLzma2Dec));

+  CLzma2Dec *decoder = (CLzma2Dec *)alloc->Alloc(alloc, sizeof(CLzma2Dec));

   p->p = decoder;

   if (decoder == 0)

     return SZ_ERROR_MEM;

@@ -337,7 +349,10 @@ void MixCoder_Free(CMixCoder *p)
   }

   p->numCoders = 0;

   if (p->buf)

+  {

     p->alloc->Free(p->alloc, p->buf);

+    p->buf = 0; /* 9.31: the BUG was fixed */

+  }

 }

 

 void MixCoder_Init(CMixCoder *p)

@@ -369,7 +384,7 @@ SRes MixCoder_SetFromMethod(CMixCoder *p, int coderIndex, UInt64 methodId)
   }

   if (coderIndex == 0)

     return SZ_ERROR_UNSUPPORTED;

-  return BraState_SetFromMethod(sc, methodId, p->alloc);

+  return BraState_SetFromMethod(sc, methodId, 0, p->alloc);

 }

 

 SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,

@@ -385,7 +400,7 @@ SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,
 

   if (p->buf == 0)

   {

-    p->buf = p->alloc->Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));

+    p->buf = (Byte *)p->alloc->Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));

     if (p->buf == 0)

       return SZ_ERROR_MEM;

   }

@@ -587,13 +602,20 @@ SRes XzDec_Init(CMixCoder *p, const CXzBlock *block)
   return SZ_OK;

 }

 

-SRes XzUnpacker_Create(CXzUnpacker *p, ISzAlloc *alloc)

+void XzUnpacker_Init(CXzUnpacker *p)

 {

-  MixCoder_Construct(&p->decoder, alloc);

   p->state = XZ_STATE_STREAM_HEADER;

   p->pos = 0;

-  p->numStreams = 0;

-  return SZ_OK;

+  p->numStartedStreams = 0;

+  p->numFinishedStreams = 0;

+  p->numTotalBlocks = 0;

+  p->padSize = 0;

+}

+

+void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc)

+{

+  MixCoder_Construct(&p->decoder, alloc);

+  XzUnpacker_Init(p);

 }

 

 void XzUnpacker_Free(CXzUnpacker *p)

@@ -602,7 +624,7 @@ void XzUnpacker_Free(CXzUnpacker *p)
 }

 

 SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,

-    const Byte *src, SizeT *srcLen, int finishMode, ECoderStatus *status)

+    const Byte *src, SizeT *srcLen, ECoderFinishMode finishMode, ECoderStatus *status)

 {

   SizeT destLenOrig = *destLen;

   SizeT srcLenOrig = *srcLen;

@@ -662,7 +684,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
       return SZ_OK;

     }

 

-    switch(p->state)

+    switch (p->state)

     {

       case XZ_STATE_STREAM_HEADER:

       {

@@ -676,6 +698,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         else

         {

           RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));

+          p->numStartedStreams++;

           p->state = XZ_STATE_BLOCK_HEADER;

           Sha256_Init(&p->sha);

           p->indexSize = 0;

@@ -716,6 +739,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         else

         {

           RINOK(XzBlock_Parse(&p->block, p->buf));

+          p->numTotalBlocks++;

           p->state = XZ_STATE_BLOCK;

           p->packSize = 0;

           p->unpackSize = 0;

@@ -833,7 +857,7 @@ SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
         if (p->pos == XZ_STREAM_FOOTER_SIZE)

         {

           p->state = XZ_STATE_STREAM_PADDING;

-          p->numStreams++;

+          p->numFinishedStreams++;

           p->padSize = 0;

           if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))

             return SZ_ERROR_CRC;

@@ -873,3 +897,13 @@ Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p)
 {

   return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);

 }

+

+UInt64 XzUnpacker_GetExtraSize(CXzUnpacker *p)

+{

+  UInt64 num = 0;

+  if (p->state == XZ_STATE_STREAM_PADDING)

+    num += p->padSize;

+  else if (p->state == XZ_STATE_STREAM_HEADER)

+    num += p->padSize + p->pos;

+  return num;

+}

diff --git a/C/XzEnc.c b/C/XzEnc.c
index e610140..3263519 100755..100644
--- a/C/XzEnc.c
+++ b/C/XzEnc.c
@@ -1,5 +1,7 @@
 /* XzEnc.c -- Xz Encode

-2009-06-04 : Igor Pavlov : Public domain */

+2014-12-30 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include <stdlib.h>

 #include <string.h>

@@ -9,7 +11,9 @@
 #include "Bra.h"

 #include "CpuArch.h"

 #ifdef USE_SUBBLOCK

-#include "SbEnc.h"

+#include "Bcj3Enc.c"

+#include "SbFind.c"

+#include "SbEnc.c"

 #endif

 

 #include "XzEnc.h"

@@ -130,7 +134,7 @@ SRes Xz_AddIndexRecord(CXzStream *p, UInt64 unpackSize, UInt64 totalSize, ISzAll
     CXzBlockSizes *blocks;

     if (newSize / sizeof(CXzBlockSizes) != num)

       return SZ_ERROR_MEM;

-    blocks = alloc->Alloc(alloc, newSize);

+    blocks = (CXzBlockSizes *)alloc->Alloc(alloc, newSize);

     if (blocks == 0)

       return SZ_ERROR_MEM;

     if (p->numBlocks != 0)

@@ -198,158 +202,147 @@ static size_t MyWrite(void *pp, const void *data, size_t size)
 

 /* ---------- CSeqInFilter ---------- */

 

-/*

-typedef struct _IFilter

-{

-  void *p;

-  void (*Free)(void *p, ISzAlloc *alloc);

-  SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAlloc *alloc);

-  void (*Init)(void *p);

-  size_t (*Filter)(void *p, Byte *data, SizeT destLen);

-} IFilter;

-

-#define FILT_BUF_SIZE (1 << 19)

+#define FILTER_BUF_SIZE (1 << 20)

 

 typedef struct

 {

   ISeqInStream p;

   ISeqInStream *realStream;

-  UInt32 x86State;

-  UInt32 ip;

-  UInt64 processed;

-  CXzCheck check;

-  Byte buf[FILT_BUF_SIZE];

-  UInt32 bufferPos;

-  UInt32 convertedPosBegin;

-  UInt32 convertedPosEnd;

-  IFilter *filter;

+  IStateCoder StateCoder;

+  Byte *buf;

+  size_t curPos;

+  size_t endPos;

+  int srcWasFinished;

 } CSeqInFilter;

 

 static SRes SeqInFilter_Read(void *pp, void *data, size_t *size)

 {

   CSeqInFilter *p = (CSeqInFilter *)pp;

-  size_t remSize = *size;

+  size_t sizeOriginal = *size;

+  if (sizeOriginal == 0)

+    return SZ_OK;

   *size = 0;

-

-  while (remSize > 0)

+  for (;;)

   {

-    int i;

-    if (p->convertedPosBegin != p->convertedPosEnd)

-    {

-      UInt32 sizeTemp = p->convertedPosEnd - p->convertedPosBegin;

-      if (remSize < sizeTemp)

-        sizeTemp = (UInt32)remSize;

-      memmove(data, p->buf + p->convertedPosBegin, sizeTemp);

-      p->convertedPosBegin += sizeTemp;

-      data = (void *)((Byte *)data + sizeTemp);

-      remSize -= sizeTemp;

-      *size += sizeTemp;

-      break;

-    }

-    for (i = 0; p->convertedPosEnd + i < p->bufferPos; i++)

-      p->buf[i] = p->buf[i + p->convertedPosEnd];

-    p->bufferPos = i;

-    p->convertedPosBegin = p->convertedPosEnd = 0;

-    {

-      size_t processedSizeTemp = FILT_BUF_SIZE - p->bufferPos;

-      RINOK(p->realStream->Read(p->realStream, p->buf + p->bufferPos, &processedSizeTemp));

-      p->bufferPos = p->bufferPos + (UInt32)processedSizeTemp;

-    }

-    p->convertedPosEnd = (UInt32)p->filter->Filter(p->filter->p, p->buf, p->bufferPos);

-    if (p->convertedPosEnd == 0)

+    if (!p->srcWasFinished && p->curPos == p->endPos)

     {

-      if (p->bufferPos == 0)

-        break;

-      else

-      {

-        p->convertedPosEnd = p->bufferPos;

-        continue;

-      }

+      p->curPos = 0;

+      p->endPos = FILTER_BUF_SIZE;

+      RINOK(p->realStream->Read(p->realStream, p->buf, &p->endPos));

+      if (p->endPos == 0)

+        p->srcWasFinished = 1;

     }

-    if (p->convertedPosEnd > p->bufferPos)

     {

-      for (; p->bufferPos < p->convertedPosEnd; p->bufferPos++)

-        p->buf[p->bufferPos] = 0;

-      p->convertedPosEnd = (UInt32)p->filter->Filter(p->filter->p, p->buf, p->bufferPos);

+      SizeT srcLen = p->endPos - p->curPos;

+      int wasFinished;

+      SRes res;

+      *size = sizeOriginal;

+      res = p->StateCoder.Code(p->StateCoder.p, data, size, p->buf + p->curPos, &srcLen,

+        p->srcWasFinished, CODER_FINISH_ANY, &wasFinished);

+      p->curPos += srcLen;

+      if (*size != 0 || srcLen == 0 || res != 0)

+        return res;

     }

   }

+}

+

+static void SeqInFilter_Construct(CSeqInFilter *p)

+{

+  p->buf = NULL;

+  p->p.Read = SeqInFilter_Read;

+}

+

+static void SeqInFilter_Free(CSeqInFilter *p)

+{

+  if (p->buf)

+  {

+    g_Alloc.Free(&g_Alloc, p->buf);

+    p->buf = NULL;

+  }

+}

+

+SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAlloc *alloc);

+

+static SRes SeqInFilter_Init(CSeqInFilter *p, const CXzFilter *props)

+{

+  if (!p->buf)

+  {

+    p->buf = g_Alloc.Alloc(&g_Alloc, FILTER_BUF_SIZE);

+    if (!p->buf)

+      return SZ_ERROR_MEM;

+  }

+  p->curPos = p->endPos = 0;

+  p->srcWasFinished = 0;

+  RINOK(BraState_SetFromMethod(&p->StateCoder, props->id, 1, &g_Alloc));

+  RINOK(p->StateCoder.SetProps(p->StateCoder.p, props->props, props->propsSize, &g_Alloc));

+  p->StateCoder.Init(p->StateCoder.p);

   return SZ_OK;

 }

-*/

 

-/*

+/* ---------- CSbEncInStream ---------- */

+

+#ifdef USE_SUBBLOCK

+

 typedef struct

 {

   ISeqInStream p;

-  ISeqInStream *realStream;

-  CMixCoder mixCoder;

-  Byte buf[FILT_BUF_SIZE];

-  UInt32 bufPos;

-  UInt32 bufSize;

-} CMixCoderSeqInStream;

+  ISeqInStream *inStream;

+  CSbEnc enc;

+} CSbEncInStream;

 

-static SRes CMixCoderSeqInStream_Read(void *pp, void *data, size_t *size)

+static SRes SbEncInStream_Read(void *pp, void *data, size_t *size)

 {

-  CMixCoderSeqInStream *p = (CMixCoderSeqInStream *)pp;

-  SRes res = SZ_OK;

-  size_t remSize = *size;

-  *size = 0;

-  while (remSize > 0)

+  CSbEncInStream *p = (CSbEncInStream *)pp;

+  size_t sizeOriginal = *size;

+  if (sizeOriginal == 0)

+    return S_OK;

+  for (;;)

   {

-    if (p->bufPos == p->bufSize)

+    if (p->enc.needRead && !p->enc.readWasFinished)

     {

-      size_t curSize;

-      p->bufPos = p->bufSize = 0;

-      if (*size != 0)

-        break;

-      curSize = FILT_BUF_SIZE;

-      RINOK(p->realStream->Read(p->realStream, p->buf, &curSize));

-      p->bufSize = (UInt32)curSize;

-    }

-    {

-      SizeT destLen = remSize;

-      SizeT srcLen = p->bufSize - p->bufPos;

-      res = MixCoder_Code(&p->mixCoder, data, &destLen, p->buf + p->bufPos, &srcLen, 0);

-      data = (void *)((Byte *)data + destLen);

-      remSize -= destLen;

-      *size += destLen;

-      p->bufPos += srcLen;

+      size_t processed = p->enc.needReadSizeMax;

+      RINOK(p->inStream->Read(p->inStream, p->enc.buf + p->enc.readPos, &processed));

+      p->enc.readPos += processed;

+      if (processed == 0)

+      {

+        p->enc.readWasFinished = True;

+        p->enc.isFinalFinished = True;

+      }

+      p->enc.needRead = False;

     }

+    *size = sizeOriginal;

+    RINOK(SbEnc_Read(&p->enc, data, size));

+    if (*size != 0 || !p->enc.needRead)

+      return S_OK;

   }

-  return res;

 }

-*/

 

-#ifdef USE_SUBBLOCK

-typedef struct

+void SbEncInStream_Construct(CSbEncInStream *p, ISzAlloc *alloc)

 {

-  ISeqInStream p;

-  CSubblockEnc sb;

-  UInt64 processed;

-} CSbEncInStream;

+  SbEnc_Construct(&p->enc, alloc);

+  p->p.Read = SbEncInStream_Read;

+}

 

-void SbEncInStream_Init(CSbEncInStream *p)

+SRes SbEncInStream_Init(CSbEncInStream *p)

 {

-  p->processed = 0;

-  SubblockEnc_Init(&p->sb);

+  return SbEnc_Init(&p->enc);

 }

 

-static SRes SbEncInStream_Read(void *pp, void *data, size_t *size)

+void SbEncInStream_Free(CSbEncInStream *p)

 {

-  CSbEncInStream *p = (CSbEncInStream *)pp;

-  SRes res = SubblockEnc_Read(&p->sb, data, size);

-  p->processed += *size;

-  return res;

+  SbEnc_Free(&p->enc);

 }

+

 #endif

 

+

 typedef struct

 {

-  /* CMixCoderSeqInStream inStream; */

   CLzma2EncHandle lzma2;

   #ifdef USE_SUBBLOCK

   CSbEncInStream sb;

   #endif

+  CSeqInFilter filter;

   ISzAlloc *alloc;

   ISzAlloc *bigAlloc;

 } CLzma2WithFilters;

@@ -361,9 +354,9 @@ static void Lzma2WithFilters_Construct(CLzma2WithFilters *p, ISzAlloc *alloc, IS
   p->bigAlloc = bigAlloc;

   p->lzma2 = NULL;

   #ifdef USE_SUBBLOCK

-  p->sb.p.Read = SbEncInStream_Read;

-  SubblockEnc_Construct(&p->sb.sb, p->alloc);

+  SbEncInStream_Construct(&p->sb, alloc);

   #endif

+  SeqInFilter_Construct(&p->filter);

 }

 

 static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p)

@@ -376,8 +369,9 @@ static SRes Lzma2WithFilters_Create(CLzma2WithFilters *p)
 

 static void Lzma2WithFilters_Free(CLzma2WithFilters *p)

 {

+  SeqInFilter_Free(&p->filter);

   #ifdef USE_SUBBLOCK

-  SubblockEnc_Free(&p->sb.sb);

+  SbEncInStream_Free(&p->sb);

   #endif

   if (p->lzma2)

   {

@@ -386,17 +380,28 @@ static void Lzma2WithFilters_Free(CLzma2WithFilters *p)
   }

 }

 

-static SRes Xz_Compress(CXzStream *xz,

-    CLzma2WithFilters *lzmaf,

-    ISeqOutStream *outStream,

-    ISeqInStream *inStream,

-    const CLzma2EncProps *lzma2Props,

-    Bool useSubblock,

-    ICompressProgress *progress)

+void XzProps_Init(CXzProps *p)

 {

-  xz->flags = XZ_CHECK_CRC32;

+  p->lzma2Props = 0;

+  p->filterProps = 0;

+  p->checkId = XZ_CHECK_CRC32;

+}

 

-  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, lzma2Props));

+void XzFilterProps_Init(CXzFilterProps *p)

+{

+  p->id = 0;

+  p->delta = 0;

+  p->ip= 0;

+  p->ipDefined = False;

+}

+

+static SRes Xz_Compress(CXzStream *xz, CLzma2WithFilters *lzmaf,

+    ISeqOutStream *outStream, ISeqInStream *inStream,

+    const CXzProps *props, ICompressProgress *progress)

+{

+  xz->flags = (Byte)props->checkId;

+

+  RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, props->lzma2Props));

   RINOK(Xz_WriteHeader(xz->flags, outStream));

 

   {

@@ -404,15 +409,27 @@ static SRes Xz_Compress(CXzStream *xz,
     CSeqSizeOutStream seqSizeOutStream;

     CXzBlock block;

     int filterIndex = 0;

+    CXzFilter *filter = NULL;

+    const CXzFilterProps *fp = props->filterProps;

     

     XzBlock_ClearFlags(&block);

-    XzBlock_SetNumFilters(&block, 1 + (useSubblock ? 1 : 0));

+    XzBlock_SetNumFilters(&block, 1 + (fp ? 1 : 0));

     

-    if (useSubblock)

+    if (fp)

     {

-      CXzFilter *f = &block.filters[filterIndex++];

-      f->id = XZ_ID_Subblock;

-      f->propsSize = 0;

+      filter = &block.filters[filterIndex++];

+      filter->id = fp->id;

+      filter->propsSize = 0;

+      if (fp->id == XZ_ID_Delta)

+      {

+        filter->props[0] = (Byte)(fp->delta - 1);

+        filter->propsSize = 1;

+      }

+      else if (fp->ipDefined)

+      {

+        SetUi32(filter->props, fp->ip);

+        filter->propsSize = 4;

+      }

     }

 

     {

@@ -432,20 +449,30 @@ static SRes Xz_Compress(CXzStream *xz,
     checkInStream.realStream = inStream;

     SeqCheckInStream_Init(&checkInStream, XzFlags_GetCheckType(xz->flags));

     

-    #ifdef USE_SUBBLOCK

-    if (useSubblock)

+    if (fp)

     {

-      lzmaf->sb.sb.inStream = &checkInStream.p;

-      SubblockEnc_Init(&lzmaf->sb.sb);

+      #ifdef USE_SUBBLOCK

+      if (fp->id == XZ_ID_Subblock)

+      {

+        lzmaf->sb.inStream = &checkInStream.p;

+        RINOK(SbEncInStream_Init(&lzmaf->sb));

+      }

+      else

+      #endif

+      {

+        lzmaf->filter.realStream = &checkInStream.p;

+        RINOK(SeqInFilter_Init(&lzmaf->filter, filter));

+      }

     }

-    #endif

-    

+

     {

       UInt64 packPos = seqSizeOutStream.processed;

       SRes res = Lzma2Enc_Encode(lzmaf->lzma2, &seqSizeOutStream.p,

+        fp ?

         #ifdef USE_SUBBLOCK

-        useSubblock ? &lzmaf->sb.p:

+        (fp->id == XZ_ID_Subblock) ? &lzmaf->sb.p:

         #endif

+        &lzmaf->filter.p:

         &checkInStream.p,

         progress);

       RINOK(res);

@@ -467,8 +494,7 @@ static SRes Xz_Compress(CXzStream *xz,
 }

 

 SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,

-    const CLzma2EncProps *lzma2Props, Bool useSubblock,

-    ICompressProgress *progress)

+    const CXzProps *props, ICompressProgress *progress)

 {

   SRes res;

   CXzStream xz;

@@ -477,8 +503,7 @@ SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,
   Lzma2WithFilters_Construct(&lzmaf, &g_Alloc, &g_BigAlloc);

   res = Lzma2WithFilters_Create(&lzmaf);

   if (res == SZ_OK)

-    res = Xz_Compress(&xz, &lzmaf, outStream, inStream,

-        lzma2Props, useSubblock, progress);

+    res = Xz_Compress(&xz, &lzmaf, outStream, inStream, props, progress);

   Lzma2WithFilters_Free(&lzmaf);

   Xz_Free(&xz, &g_Alloc);

   return res;

diff --git a/C/XzEnc.h b/C/XzEnc.h
index aad9aa4..e9cea34 100755..100644
--- a/C/XzEnc.h
+++ b/C/XzEnc.h
@@ -1,5 +1,5 @@
 /* XzEnc.h -- Xz Encode

-2009-04-15 : Igor Pavlov : Public domain */

+2011-02-07 : Igor Pavlov : Public domain */

 

 #ifndef __XZ_ENC_H

 #define __XZ_ENC_H

@@ -8,18 +8,32 @@
 

 #include "Xz.h"

 

-#ifdef __cplusplus

-extern "C" {

-#endif

+EXTERN_C_BEGIN

+

+typedef struct

+{

+  UInt32 id;

+  UInt32 delta;

+  UInt32 ip;

+  int ipDefined;

+} CXzFilterProps;

+

+void XzFilterProps_Init(CXzFilterProps *p);

+

+typedef struct

+{

+  const CLzma2EncProps *lzma2Props;

+  const CXzFilterProps *filterProps;

+  unsigned checkId;

+} CXzProps;

+

+void XzProps_Init(CXzProps *p);

 

 SRes Xz_Encode(ISeqOutStream *outStream, ISeqInStream *inStream,

-    const CLzma2EncProps *lzma2Props, Bool useSubblock,

-    ICompressProgress *progress);

+    const CXzProps *props, ICompressProgress *progress);

 

 SRes Xz_EncodeEmpty(ISeqOutStream *outStream);

 

-#ifdef __cplusplus

-}

-#endif

+EXTERN_C_END

 

 #endif

diff --git a/C/XzIn.c b/C/XzIn.c
index 356d019..c99d71c 100755..100644
--- a/C/XzIn.c
+++ b/C/XzIn.c
@@ -1,5 +1,7 @@
 /* XzIn.c - Xz input

-2009-06-19 : Igor Pavlov : Public domain */

+2014-12-30 : Igor Pavlov : Public domain */

+

+#include "Precomp.h"

 

 #include <string.h>

 

@@ -70,7 +72,7 @@ SRes XzBlock_ReadFooter(CXzBlock *p, CXzStreamFlags f, ISeqInStream *inStream)
 

 static SRes Xz_ReadIndex2(CXzStream *p, const Byte *buf, size_t size, ISzAlloc *alloc)

 {

-  size_t i, numBlocks, crcStartPos, pos = 1;

+  size_t i, numBlocks, pos = 1;

   UInt32 crc;

 

   if (size < 5 || buf[0] != 0)

@@ -89,7 +91,6 @@ static SRes Xz_ReadIndex2(CXzStream *p, const Byte *buf, size_t size, ISzAlloc *
       return SZ_ERROR_ARCHIVE;

   }

   

-  crcStartPos = pos;

   Xz_Free(p, alloc);

   if (numBlocks != 0)

   {

@@ -152,39 +153,38 @@ static SRes Xz_ReadBackward(CXzStream *p, ILookInStream *stream, Int64 *startOff
   

   if (memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) != 0)

   {

-    Int64 i = 0;

+    UInt32 total = 0;

     *startOffset += XZ_STREAM_FOOTER_SIZE;

     for (;;)

     {

-      int j;

-      size_t processedSize;

+      size_t i;

       #define TEMP_BUF_SIZE (1 << 10)

       Byte tempBuf[TEMP_BUF_SIZE];

-      if (*startOffset < XZ_STREAM_FOOTER_SIZE || i > (1 << 16))

+      if (*startOffset < XZ_STREAM_FOOTER_SIZE || total > (1 << 16))

         return SZ_ERROR_NO_ARCHIVE;

-      processedSize = (*startOffset > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)*startOffset;

-      i += processedSize;

-      *startOffset = -(Int64)processedSize;

+      i = (*startOffset > TEMP_BUF_SIZE) ? TEMP_BUF_SIZE : (size_t)*startOffset;

+      total += (UInt32)i;

+      *startOffset = -(Int64)i;

       RINOK(SeekFromCur(stream, startOffset));

-      RINOK(LookInStream_Read2(stream, tempBuf, processedSize, SZ_ERROR_NO_ARCHIVE));

-      for (j = (int)processedSize; j >= 0; j--)

-        if (tempBuf[j -1] != 0)

+      RINOK(LookInStream_Read2(stream, tempBuf, i, SZ_ERROR_NO_ARCHIVE));

+      for (; i != 0; i--)

+        if (tempBuf[i - 1] != 0)

           break;

-      if (j != 0)

+      if (i != 0)

       {

-        if ((j & 3) != 0)

-          return SZ_ERROR_NO_ARCHIVE;

-        *startOffset += j;

-        if (*startOffset < XZ_STREAM_FOOTER_SIZE)

-          return SZ_ERROR_NO_ARCHIVE;

-        *startOffset -= XZ_STREAM_FOOTER_SIZE;

-        RINOK(stream->Seek(stream, startOffset, SZ_SEEK_SET));

-        RINOK(LookInStream_Read2(stream, buf, XZ_STREAM_FOOTER_SIZE, SZ_ERROR_NO_ARCHIVE));

-        if (memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) != 0)

+        if ((i & 3) != 0)

           return SZ_ERROR_NO_ARCHIVE;

+        *startOffset += i;

         break;

       }

     }

+    if (*startOffset < XZ_STREAM_FOOTER_SIZE)

+      return SZ_ERROR_NO_ARCHIVE;

+    *startOffset -= XZ_STREAM_FOOTER_SIZE;

+    RINOK(stream->Seek(stream, startOffset, SZ_SEEK_SET));

+    RINOK(LookInStream_Read2(stream, buf, XZ_STREAM_FOOTER_SIZE, SZ_ERROR_NO_ARCHIVE));

+    if (memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) != 0)

+      return SZ_ERROR_NO_ARCHIVE;

   }

   

   p->flags = (CXzStreamFlags)GetBe16(buf + 8);

@@ -291,7 +291,8 @@ SRes Xzs_ReadBackward(CXzs *p, ILookInStream *stream, Int64 *startOffset, ICompr
       if (data == 0)

         return SZ_ERROR_MEM;

       p->numAllocated = newNum;

-      memcpy(data, p->streams, p->num * sizeof(CXzStream));

+      if (p->num != 0)

+        memcpy(data, p->streams, p->num * sizeof(CXzStream));

       alloc->Free(alloc, p->streams);

       p->streams = (CXzStream *)data;

     }