(7z) Use stdint types - Types.h was conflicting with OSX 10.6

headers
This commit is contained in:
twinaphex 2014-10-20 04:28:20 +02:00
parent dd79cf0b93
commit 26833c35c9
25 changed files with 707 additions and 747 deletions

@ -47,16 +47,16 @@ static int Buf_EnsureSize(CBuf *dest, size_t size)
#ifndef _WIN32 #ifndef _WIN32
static Byte kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; static uint8_t kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
static Bool Utf16_To_Utf8(Byte *dest, size_t *destLen, static Bool Utf16_To_Utf8(uint8_t *dest, size_t *destLen,
const UInt16 *src, size_t srcLen) const uint16_t *src, size_t srcLen)
{ {
size_t destPos = 0, srcPos = 0; size_t destPos = 0, srcPos = 0;
for (;;) for (;;)
{ {
unsigned numAdds; unsigned numAdds;
UInt32 value; uint32_t value;
if (srcPos == srcLen) if (srcPos == srcLen)
{ {
*destLen = destPos; *destLen = destPos;
@ -72,7 +72,7 @@ static Bool Utf16_To_Utf8(Byte *dest, size_t *destLen,
} }
if (value >= 0xD800 && value < 0xE000) if (value >= 0xD800 && value < 0xE000)
{ {
UInt32 c2; uint32_t c2;
if (value >= 0xDC00 || srcPos == srcLen) if (value >= 0xDC00 || srcPos == srcLen)
break; break;
c2 = src[srcPos++]; c2 = src[srcPos++];
@ -81,7 +81,7 @@ static Bool Utf16_To_Utf8(Byte *dest, size_t *destLen,
value = (((value - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000; value = (((value - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
} }
for (numAdds = 1; numAdds < 5; numAdds++) for (numAdds = 1; numAdds < 5; numAdds++)
if (value < (((UInt32)1) << (numAdds * 5 + 6))) if (value < (((uint32_t)1) << (numAdds * 5 + 6)))
break; break;
if (dest) if (dest)
dest[destPos] = (char)(kUtf8Limits[numAdds - 1] dest[destPos] = (char)(kUtf8Limits[numAdds - 1]
@ -102,7 +102,7 @@ static Bool Utf16_To_Utf8(Byte *dest, size_t *destLen,
} }
static SRes Utf16_To_Utf8Buf(CBuf *dest, static SRes Utf16_To_Utf8Buf(CBuf *dest,
const UInt16 *src, size_t srcLen) const uint16_t *src, size_t srcLen)
{ {
size_t destLen = 0; size_t destLen = 0;
Bool res; Bool res;
@ -116,7 +116,7 @@ static SRes Utf16_To_Utf8Buf(CBuf *dest,
} }
#endif #endif
static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s, int fileMode) static SRes Utf16_To_Char(CBuf *buf, const uint16_t *s, int fileMode)
{ {
int len = 0; int len = 0;
for (len = 0; s[len] != '\0'; len++); for (len = 0; s[len] != '\0'; len++);
@ -152,7 +152,7 @@ static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s, int fileMode)
} }
static SRes ConvertUtf16toCharString(const UInt16 *s, char *outstring) static SRes ConvertUtf16toCharString(const uint16_t *s, char *outstring)
{ {
CBuf buf; CBuf buf;
SRes res; SRes res;
@ -179,7 +179,7 @@ int read_7zip_file(const char * archive_path,
SRes res; SRes res;
ISzAlloc allocImp; ISzAlloc allocImp;
ISzAlloc allocTempImp; ISzAlloc allocTempImp;
UInt16 *temp = NULL; uint16_t *temp = NULL;
size_t tempSize = 0; size_t tempSize = 0;
long outsize = -1; long outsize = -1;
bool file_found = false; bool file_found = false;
@ -210,9 +210,9 @@ int read_7zip_file(const char * archive_path,
res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp); res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);
if (res == SZ_OK) if (res == SZ_OK)
{ {
UInt32 i; uint32_t i;
UInt32 blockIndex = 0xFFFFFFFF; uint32_t blockIndex = 0xFFFFFFFF;
Byte *outBuffer = 0; uint8_t *outBuffer = 0;
size_t outBufferSize = 0; size_t outBufferSize = 0;
for (i = 0; i < db.db.NumFiles; i++) for (i = 0; i < db.db.NumFiles; i++)
@ -233,7 +233,7 @@ int read_7zip_file(const char * archive_path,
{ {
SzFree(NULL, temp); SzFree(NULL, temp);
tempSize = len; tempSize = len;
temp = (UInt16 *)SzAlloc(NULL, tempSize * sizeof(temp[0])); temp = (uint16_t *)SzAlloc(NULL, tempSize * sizeof(temp[0]));
if (temp == 0) if (temp == 0)
{ {
res = SZ_ERROR_MEM; res = SZ_ERROR_MEM;
@ -244,7 +244,7 @@ int read_7zip_file(const char * archive_path,
char infile[PATH_MAX]; char infile[PATH_MAX];
res = ConvertUtf16toCharString(temp,infile); res = ConvertUtf16toCharString(temp,infile);
UInt64 filesize = f->Size; uint64_t filesize = f->Size;
(void)filesize; (void)filesize;
@ -338,7 +338,7 @@ struct string_list *compressed_7zip_file_list_new(const char *path,
SRes res; SRes res;
ISzAlloc allocImp; ISzAlloc allocImp;
ISzAlloc allocTempImp; ISzAlloc allocTempImp;
UInt16 *temp = NULL; uint16_t *temp = NULL;
size_t tempSize = 0; size_t tempSize = 0;
long outsize = -1; long outsize = -1;
@ -365,9 +365,9 @@ struct string_list *compressed_7zip_file_list_new(const char *path,
res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp); res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);
if (res == SZ_OK) if (res == SZ_OK)
{ {
UInt32 i; uint32_t i;
UInt32 blockIndex = 0xFFFFFFFF; uint32_t blockIndex = 0xFFFFFFFF;
Byte *outBuffer = 0; uint8_t *outBuffer = 0;
size_t outBufferSize = 0; size_t outBufferSize = 0;
(void)blockIndex; (void)blockIndex;
@ -394,7 +394,7 @@ struct string_list *compressed_7zip_file_list_new(const char *path,
{ {
SzFree(NULL, temp); SzFree(NULL, temp);
tempSize = len; tempSize = len;
temp = (UInt16 *) SzAlloc(NULL, tempSize * sizeof(temp[0])); temp = (uint16_t *) SzAlloc(NULL, tempSize * sizeof(temp[0]));
if (temp == 0) if (temp == 0)
{ {
res = SZ_ERROR_MEM; res = SZ_ERROR_MEM;

98
deps/7zip/7z.h vendored

@ -10,7 +10,7 @@ EXTERN_C_BEGIN
#define k7zStartHeaderSize 0x20 #define k7zStartHeaderSize 0x20
#define k7zSignatureSize 6 #define k7zSignatureSize 6
extern Byte k7zSignature[k7zSignatureSize]; extern uint8_t k7zSignature[k7zSignatureSize];
#define k7zMajorVersion 0 #define k7zMajorVersion 0
enum EIdEnum enum EIdEnum
@ -45,9 +45,9 @@ enum EIdEnum
typedef struct typedef struct
{ {
UInt32 NumInStreams; uint32_t NumInStreams;
UInt32 NumOutStreams; uint32_t NumOutStreams;
UInt64 MethodID; uint64_t MethodID;
CBuf Props; CBuf Props;
} CSzCoderInfo; } CSzCoderInfo;
@ -56,67 +56,67 @@ void SzCoderInfo_Free(CSzCoderInfo *p, ISzAlloc *alloc);
typedef struct typedef struct
{ {
UInt32 InIndex; uint32_t InIndex;
UInt32 OutIndex; uint32_t OutIndex;
} CSzBindPair; } CSzBindPair;
typedef struct typedef struct
{ {
CSzCoderInfo *Coders; CSzCoderInfo *Coders;
CSzBindPair *BindPairs; CSzBindPair *BindPairs;
UInt32 *PackStreams; uint32_t *PackStreams;
UInt64 *UnpackSizes; uint64_t *UnpackSizes;
UInt32 NumCoders; uint32_t NumCoders;
UInt32 NumBindPairs; uint32_t NumBindPairs;
UInt32 NumPackStreams; uint32_t NumPackStreams;
int UnpackCRCDefined; int UnpackCRCDefined;
UInt32 UnpackCRC; uint32_t UnpackCRC;
UInt32 NumUnpackStreams; uint32_t NumUnpackStreams;
} CSzFolder; } CSzFolder;
void SzFolder_Init(CSzFolder *p); void SzFolder_Init(CSzFolder *p);
UInt64 SzFolder_GetUnpackSize(CSzFolder *p); uint64_t SzFolder_GetUnpackSize(CSzFolder *p);
int SzFolder_FindBindPairForInStream(CSzFolder *p, UInt32 inStreamIndex); int SzFolder_FindBindPairForInStream(CSzFolder *p, uint32_t inStreamIndex);
UInt32 SzFolder_GetNumOutStreams(CSzFolder *p); uint32_t SzFolder_GetNumOutStreams(CSzFolder *p);
UInt64 SzFolder_GetUnpackSize(CSzFolder *p); uint64_t SzFolder_GetUnpackSize(CSzFolder *p);
SRes SzFolder_Decode(const CSzFolder *folder, const UInt64 *packSizes, SRes SzFolder_Decode(const CSzFolder *folder, const uint64_t *packSizes,
ILookInStream *stream, UInt64 startPos, ILookInStream *stream, uint64_t startPos,
Byte *outBuffer, size_t outSize, ISzAlloc *allocMain); uint8_t *outBuffer, size_t outSize, ISzAlloc *allocMain);
typedef struct typedef struct
{ {
UInt32 Low; uint32_t Low;
UInt32 High; uint32_t High;
} CNtfsFileTime; } CNtfsFileTime;
typedef struct typedef struct
{ {
CNtfsFileTime MTime; CNtfsFileTime MTime;
UInt64 Size; uint64_t Size;
UInt32 Crc; uint32_t Crc;
UInt32 Attrib; uint32_t Attrib;
Byte HasStream; uint8_t HasStream;
Byte IsDir; uint8_t IsDir;
Byte IsAnti; uint8_t IsAnti;
Byte CrcDefined; uint8_t CrcDefined;
Byte MTimeDefined; uint8_t MTimeDefined;
Byte AttribDefined; uint8_t AttribDefined;
} CSzFileItem; } CSzFileItem;
void SzFile_Init(CSzFileItem *p); void SzFile_Init(CSzFileItem *p);
typedef struct typedef struct
{ {
UInt64 *PackSizes; uint64_t *PackSizes;
Byte *PackCRCsDefined; uint8_t *PackCRCsDefined;
UInt32 *PackCRCs; uint32_t *PackCRCs;
CSzFolder *Folders; CSzFolder *Folders;
CSzFileItem *Files; CSzFileItem *Files;
UInt32 NumPackStreams; uint32_t NumPackStreams;
UInt32 NumFolders; uint32_t NumFolders;
UInt32 NumFiles; uint32_t NumFiles;
} CSzAr; } CSzAr;
void SzAr_Init(CSzAr *p); void SzAr_Init(CSzAr *p);
@ -147,13 +147,13 @@ typedef struct
{ {
CSzAr db; CSzAr db;
UInt64 startPosAfterHeader; uint64_t startPosAfterHeader;
UInt64 dataPos; uint64_t dataPos;
UInt32 *FolderStartPackStreamIndex; uint32_t *FolderStartPackStreamIndex;
UInt64 *PackStreamStartPositions; uint64_t *PackStreamStartPositions;
UInt32 *FolderStartFileIndex; uint32_t *FolderStartFileIndex;
UInt32 *FileIndexToFolderIndexMap; uint32_t *FileIndexToFolderIndexMap;
size_t *FileNameOffsets; /* in 2-byte steps */ size_t *FileNameOffsets; /* in 2-byte steps */
CBuf FileNames; /* UTF-16-LE */ CBuf FileNames; /* UTF-16-LE */
@ -161,8 +161,8 @@ typedef struct
void SzArEx_Init(CSzArEx *p); void SzArEx_Init(CSzArEx *p);
void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc); void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc);
UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder); uint64_t SzArEx_GetFolderStreamPos(const CSzArEx *p, uint32_t folderIndex, uint32_t indexInFolder);
int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize); int SzArEx_GetFolderFullPackSize(const CSzArEx *p, uint32_t folderIndex, uint64_t *resSize);
/* /*
if dest == NULL, the return value specifies the required size of the buffer, if dest == NULL, the return value specifies the required size of the buffer,
@ -170,14 +170,14 @@ if dest == NULL, the return value specifies the required size of the buffer,
if dest != NULL, the return value specifies the number of 16-bit characters that if dest != NULL, the return value specifies the number of 16-bit characters that
are written to the dest, including the null-terminating character. */ are written to the dest, including the null-terminating character. */
size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest); size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, uint16_t *dest);
SRes SzArEx_Extract( SRes SzArEx_Extract(
const CSzArEx *db, const CSzArEx *db,
ILookInStream *inStream, ILookInStream *inStream,
UInt32 fileIndex, /* index of file */ uint32_t fileIndex, /* index of file */
UInt32 *blockIndex, /* index of solid block */ uint32_t *blockIndex, /* index of solid block */
Byte **outBuffer, /* pointer to pointer to output buffer (allocated with allocMain) */ uint8_t **outBuffer, /* pointer to pointer to output buffer (allocated with allocMain) */
size_t *outBufferSize, /* buffer size for output buffer */ size_t *outBufferSize, /* buffer size for output buffer */
size_t *offset, /* offset of stream for required file in *outBuffer */ size_t *offset, /* offset of stream for required file in *outBuffer */
size_t *outSizeProcessed, /* size of file in *outBuffer */ size_t *outSizeProcessed, /* size of file in *outBuffer */

3
deps/7zip/7zBuf.c vendored

@ -3,6 +3,7 @@
Igor Pavlov Igor Pavlov
Public domain */ Public domain */
#include <stdint.h>
#include "7zBuf.h" #include "7zBuf.h"
void Buf_Init(CBuf *p) void Buf_Init(CBuf *p)
@ -19,7 +20,7 @@ int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc)
p->data = 0; p->data = 0;
return 1; return 1;
} }
p->data = (Byte *)alloc->Alloc(alloc, size); p->data = (uint8_t *)alloc->Alloc(alloc, size);
if (p->data != 0) if (p->data != 0)
{ {
p->size = size; p->size = size;

6
deps/7zip/7zBuf.h vendored

@ -12,7 +12,7 @@ extern "C" {
typedef struct typedef struct
{ {
Byte *data; uint8_t *data;
size_t size; size_t size;
} CBuf; } CBuf;
@ -22,14 +22,14 @@ void Buf_Free(CBuf *p, ISzAlloc *alloc);
typedef struct typedef struct
{ {
Byte *data; uint8_t *data;
size_t size; size_t size;
size_t pos; size_t pos;
} CDynBuf; } CDynBuf;
void DynBuf_Construct(CDynBuf *p); void DynBuf_Construct(CDynBuf *p);
void DynBuf_SeekToBeg(CDynBuf *p); void DynBuf_SeekToBeg(CDynBuf *p);
int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc); int DynBuf_Write(CDynBuf *p, const uint8_t *buf, size_t size, ISzAlloc *alloc);
void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc); void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc);
#ifdef __cplusplus #ifdef __cplusplus

9
deps/7zip/7zBuf2.c vendored

@ -1,6 +1,7 @@
/* 7zBuf2.c -- Byte Buffer /* 7zBuf2.c -- uint8_t Buffer
2008-10-04 : Igor Pavlov : Public domain */ 2008-10-04 : Igor Pavlov : Public domain */
#include <stdint.h>
#include <string.h> #include <string.h>
#include "7zBuf.h" #include "7zBuf.h"
@ -16,14 +17,14 @@ void DynBuf_SeekToBeg(CDynBuf *p)
p->pos = 0; p->pos = 0;
} }
int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc) int DynBuf_Write(CDynBuf *p, const uint8_t *buf, size_t size, ISzAlloc *alloc)
{ {
if (size > p->size - p->pos) if (size > p->size - p->pos)
{ {
size_t newSize = p->pos + size; size_t newSize = p->pos + size;
Byte *data; uint8_t *data;
newSize += newSize / 4; newSize += newSize / 4;
data = (Byte *)alloc->Alloc(alloc, newSize); data = (uint8_t *)alloc->Alloc(alloc, newSize);
if (data == 0) if (data == 0)
return 0; return 0;
p->size = newSize; p->size = newSize;

23
deps/7zip/7zCrc.c vendored

@ -1,6 +1,7 @@
/* 7zCrc.c -- CRC32 calculation /* 7zCrc.c -- CRC32 calculation
2009-11-23 : Igor Pavlov : Public domain */ 2009-11-23 : Igor Pavlov : Public domain */
#include <stdint.h>
#include "7zCrc.h" #include "7zCrc.h"
#include "CpuArch.h" #include "CpuArch.h"
@ -12,18 +13,18 @@
#define CRC_NUM_TABLES 1 #define CRC_NUM_TABLES 1
#endif #endif
typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table); typedef uint32_t (MY_FAST_CALL *CRC_FUNC)(uint32_t v, const void *data, size_t size, const uint32_t *table);
static CRC_FUNC g_CrcUpdate; static CRC_FUNC g_CrcUpdate;
UInt32 g_CrcTable[256 * CRC_NUM_TABLES]; uint32_t g_CrcTable[256 * CRC_NUM_TABLES];
#if CRC_NUM_TABLES == 1 #if CRC_NUM_TABLES == 1
#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8)) #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) static uint32_t MY_FAST_CALL CrcUpdateT1(uint32_t v, const void *data, size_t size, const uint32_t *table)
{ {
const Byte *p = (const Byte *)data; const uint8_t *p = (const uint8_t *)data;
for (; size > 0; size--, p++) for (; size > 0; size--, p++)
v = CRC_UPDATE_BYTE_2(v, *p); v = CRC_UPDATE_BYTE_2(v, *p);
return v; return v;
@ -31,27 +32,27 @@ static UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size,
#else #else
UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table); uint32_t MY_FAST_CALL CrcUpdateT4(uint32_t v, const void *data, size_t size, const uint32_t *table);
UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table); uint32_t MY_FAST_CALL CrcUpdateT8(uint32_t v, const void *data, size_t size, const uint32_t *table);
#endif #endif
UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size) uint32_t MY_FAST_CALL CrcUpdate(uint32_t v, const void *data, size_t size)
{ {
return g_CrcUpdate(v, data, size, g_CrcTable); return g_CrcUpdate(v, data, size, g_CrcTable);
} }
UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size) uint32_t MY_FAST_CALL CrcCalc(const void *data, size_t size)
{ {
return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL; return g_CrcUpdate(CRC_INIT_VAL, data, size, g_CrcTable) ^ CRC_INIT_VAL;
} }
void MY_FAST_CALL CrcGenerateTable() void MY_FAST_CALL CrcGenerateTable()
{ {
UInt32 i; uint32_t i;
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
{ {
UInt32 r = i; uint32_t r = i;
unsigned j; unsigned j;
for (j = 0; j < 8; j++) for (j = 0; j < 8; j++)
r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1)); r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
@ -62,7 +63,7 @@ void MY_FAST_CALL CrcGenerateTable()
#else #else
for (; i < 256 * CRC_NUM_TABLES; i++) for (; i < 256 * CRC_NUM_TABLES; i++)
{ {
UInt32 r = g_CrcTable[i - 256]; uint32_t r = g_CrcTable[i - 256];
g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8); g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
} }
g_CrcUpdate = CrcUpdateT4; g_CrcUpdate = CrcUpdateT4;

6
deps/7zip/7zCrc.h vendored

@ -8,7 +8,7 @@
EXTERN_C_BEGIN EXTERN_C_BEGIN
extern UInt32 g_CrcTable[]; extern uint32_t g_CrcTable[];
/* Call CrcGenerateTable one time before other CRC functions */ /* Call CrcGenerateTable one time before other CRC functions */
void MY_FAST_CALL CrcGenerateTable(void); void MY_FAST_CALL CrcGenerateTable(void);
@ -17,8 +17,8 @@ void MY_FAST_CALL CrcGenerateTable(void);
#define CRC_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL) #define CRC_GET_DIGEST(crc) ((crc) ^ CRC_INIT_VAL)
#define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8)) #define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
UInt32 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size); uint32_t MY_FAST_CALL CrcUpdate(uint32_t crc, const void *data, size_t size);
UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size); uint32_t MY_FAST_CALL CrcCalc(const void *data, size_t size);
EXTERN_C_END EXTERN_C_END

13
deps/7zip/7zCrcOpt.c vendored

@ -1,23 +1,24 @@
/* 7zCrcOpt.c -- CRC32 calculation : optimized version /* 7zCrcOpt.c -- CRC32 calculation : optimized version
2009-11-23 : Igor Pavlov : Public domain */ 2009-11-23 : Igor Pavlov : Public domain */
#include <stdint.h>
#include "CpuArch.h" #include "CpuArch.h"
#ifdef MY_CPU_LE #ifdef MY_CPU_LE
#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8)) #define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table); uint32_t MY_FAST_CALL CrcUpdateT4(uint32_t v, const void *data, size_t size, const uint32_t *table);
UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table); uint32_t MY_FAST_CALL CrcUpdateT8(uint32_t v, const void *data, size_t size, const uint32_t *table);
UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table) uint32_t MY_FAST_CALL CrcUpdateT4(uint32_t v, const void *data, size_t size, const uint32_t *table)
{ {
const Byte *p = (const Byte *)data; const uint8_t *p = (const uint8_t*)data;
for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++) for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
v = CRC_UPDATE_BYTE_2(v, *p); v = CRC_UPDATE_BYTE_2(v, *p);
for (; size >= 4; size -= 4, p += 4) for (; size >= 4; size -= 4, p += 4)
{ {
v ^= *(const UInt32 *)p; v ^= *(const uint32_t *)p;
v = v =
table[0x300 + (v & 0xFF)] ^ table[0x300 + (v & 0xFF)] ^
table[0x200 + ((v >> 8) & 0xFF)] ^ table[0x200 + ((v >> 8) & 0xFF)] ^
@ -29,7 +30,7 @@ UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const U
return v; return v;
} }
UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table) uint32_t MY_FAST_CALL CrcUpdateT8(uint32_t v, const void *data, size_t size, const uint32_t *table)
{ {
return CrcUpdateT4(v, data, size, table); return CrcUpdateT4(v, data, size, table);
} }

125
deps/7zip/7zDec.c vendored

@ -1,6 +1,7 @@
/* 7zDec.c -- Decoding from 7z folder /* 7zDec.c -- Decoding from 7z folder
2010-11-02 : Igor Pavlov : Public domain */ 2010-11-02 : Igor Pavlov : Public domain */
#include <stdint.h>
#include <string.h> #include <string.h>
/* #define _7ZIP_PPMD_SUPPPORT */ /* #define _7ZIP_PPMD_SUPPPORT */
@ -32,19 +33,19 @@
typedef struct typedef struct
{ {
IByteIn p; Iuint8_tIn p;
const Byte *cur; const uint8_t *cur;
const Byte *end; const uint8_t *end;
const Byte *begin; const uint8_t *begin;
UInt64 processed; uint64_t processed;
Bool extra; Bool extra;
SRes res; SRes res;
ILookInStream *inStream; ILookInStream *inStream;
} CByteInToLook; } Cuint8_tInToLook;
static Byte ReadByte(void *pp) static uint8_t Readuint8_t(void *pp)
{ {
CByteInToLook *p = (CByteInToLook *)pp; Cuint8_tInToLook *p = (Cuint8_tInToLook *)pp;
if (p->cur != p->end) if (p->cur != p->end)
return *p->cur++; return *p->cur++;
if (p->res == SZ_OK) if (p->res == SZ_OK)
@ -63,14 +64,14 @@ static Byte ReadByte(void *pp)
return 0; return 0;
} }
static SRes SzDecodePpmd(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream, static SRes SzDecodePpmd(CSzCoderInfo *coder, uint64_t inSize, ILookInStream *inStream,
Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain) uint8_t *outBuffer, size_t outSize, ISzAlloc *allocMain)
{ {
CPpmd7 ppmd; CPpmd7 ppmd;
CByteInToLook s; Cuint8_tInToLook s;
SRes res = SZ_OK; SRes res = SZ_OK;
s.p.Read = ReadByte; s.p.Read = Readuint8_t;
s.inStream = inStream; s.inStream = inStream;
s.begin = s.end = s.cur = NULL; s.begin = s.end = s.cur = NULL;
s.extra = False; s.extra = False;
@ -82,7 +83,7 @@ static SRes SzDecodePpmd(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
{ {
unsigned order = coder->Props.data[0]; unsigned order = coder->Props.data[0];
UInt32 memSize = GetUi32(coder->Props.data + 1); uint32_t memSize = GetUi32(coder->Props.data + 1);
if (order < PPMD7_MIN_ORDER || if (order < PPMD7_MIN_ORDER ||
order > PPMD7_MAX_ORDER || order > PPMD7_MAX_ORDER ||
memSize < PPMD7_MIN_MEM_SIZE || memSize < PPMD7_MIN_MEM_SIZE ||
@ -103,13 +104,13 @@ static SRes SzDecodePpmd(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA); res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
else else
{ {
SizeT i; size_t i;
for (i = 0; i < outSize; i++) for (i = 0; i < outSize; i++)
{ {
int sym = Ppmd7_DecodeSymbol(&ppmd, &rc.p); int sym = Ppmd7_DecodeSymbol(&ppmd, &rc.p);
if (s.extra || sym < 0) if (s.extra || sym < 0)
break; break;
outBuffer[i] = (Byte)sym; outBuffer[i] = (uint8_t)sym;
} }
if (i != outSize) if (i != outSize)
res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA); res = (s.res != SZ_OK ? s.res : SZ_ERROR_DATA);
@ -124,8 +125,8 @@ static SRes SzDecodePpmd(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
#endif #endif
static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream, static SRes SzDecodeLzma(CSzCoderInfo *coder, uint64_t inSize, ILookInStream *inStream,
Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain) uint8_t *outBuffer, size_t outSize, ISzAlloc *allocMain)
{ {
CLzmaDec state; CLzmaDec state;
SRes res = SZ_OK; SRes res = SZ_OK;
@ -138,7 +139,7 @@ static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
for (;;) for (;;)
{ {
Byte *inBuf = NULL; uint8_t *inBuf = NULL;
size_t lookahead = (1 << 18); size_t lookahead = (1 << 18);
if (lookahead > inSize) if (lookahead > inSize)
lookahead = (size_t)inSize; lookahead = (size_t)inSize;
@ -147,7 +148,7 @@ static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
break; break;
{ {
SizeT inProcessed = (SizeT)lookahead, dicPos = state.dicPos; size_t inProcessed = (size_t)lookahead, dicPos = state.dicPos;
ELzmaStatus status; ELzmaStatus status;
res = LzmaDec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status); res = LzmaDec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);
lookahead -= inProcessed; lookahead -= inProcessed;
@ -172,8 +173,8 @@ static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inSt
return res; return res;
} }
static SRes SzDecodeLzma2(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream, static SRes SzDecodeLzma2(CSzCoderInfo *coder, uint64_t inSize, ILookInStream *inStream,
Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain) uint8_t *outBuffer, size_t outSize, ISzAlloc *allocMain)
{ {
CLzma2Dec state; CLzma2Dec state;
SRes res = SZ_OK; SRes res = SZ_OK;
@ -188,7 +189,7 @@ static SRes SzDecodeLzma2(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inS
for (;;) for (;;)
{ {
Byte *inBuf = NULL; uint8_t *inBuf = NULL;
size_t lookahead = (1 << 18); size_t lookahead = (1 << 18);
if (lookahead > inSize) if (lookahead > inSize)
lookahead = (size_t)inSize; lookahead = (size_t)inSize;
@ -197,7 +198,7 @@ static SRes SzDecodeLzma2(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inS
break; break;
{ {
SizeT inProcessed = (SizeT)lookahead, dicPos = state.decoder.dicPos; size_t inProcessed = (size_t)lookahead, dicPos = state.decoder.dicPos;
ELzmaStatus status; ELzmaStatus status;
res = Lzma2Dec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status); res = Lzma2Dec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);
lookahead -= inProcessed; lookahead -= inProcessed;
@ -221,7 +222,7 @@ static SRes SzDecodeLzma2(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inS
return res; return res;
} }
static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer) static SRes SzDecodeCopy(uint64_t inSize, ILookInStream *inStream, uint8_t *outBuffer)
{ {
while (inSize > 0) while (inSize > 0)
{ {
@ -240,7 +241,7 @@ static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer
return SZ_OK; return SZ_OK;
} }
static Bool IS_MAIN_METHOD(UInt32 m) static Bool IS_MAIN_METHOD(uint32_t m)
{ {
switch(m) switch(m)
{ {
@ -260,8 +261,8 @@ static Bool IS_SUPPORTED_CODER(const CSzCoderInfo *c)
return return
c->NumInStreams == 1 && c->NumInStreams == 1 &&
c->NumOutStreams == 1 && c->NumOutStreams == 1 &&
c->MethodID <= (UInt32)0xFFFFFFFF && c->MethodID <= (uint32_t)0xFFFFFFFF &&
IS_MAIN_METHOD((UInt32)c->MethodID); IS_MAIN_METHOD((uint32_t)c->MethodID);
} }
#define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumInStreams == 4 && (c)->NumOutStreams == 1) #define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumInStreams == 4 && (c)->NumOutStreams == 1)
@ -281,7 +282,7 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
if (f->NumCoders == 2) if (f->NumCoders == 2)
{ {
CSzCoderInfo *c = &f->Coders[1]; CSzCoderInfo *c = &f->Coders[1];
if (c->MethodID > (UInt32)0xFFFFFFFF || if (c->MethodID > (uint32_t)0xFFFFFFFF ||
c->NumInStreams != 1 || c->NumInStreams != 1 ||
c->NumOutStreams != 1 || c->NumOutStreams != 1 ||
f->NumPackStreams != 1 || f->NumPackStreams != 1 ||
@ -290,7 +291,7 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
f->BindPairs[0].InIndex != 1 || f->BindPairs[0].InIndex != 1 ||
f->BindPairs[0].OutIndex != 0) f->BindPairs[0].OutIndex != 0)
return SZ_ERROR_UNSUPPORTED; return SZ_ERROR_UNSUPPORTED;
switch ((UInt32)c->MethodID) switch ((uint32_t)c->MethodID)
{ {
case k_BCJ: case k_BCJ:
case k_ARM: case k_ARM:
@ -321,10 +322,10 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
return SZ_ERROR_UNSUPPORTED; return SZ_ERROR_UNSUPPORTED;
} }
static UInt64 GetSum(const UInt64 *values, UInt32 index) static uint64_t GetSum(const uint64_t *values, uint32_t index)
{ {
UInt64 sum = 0; uint64_t sum = 0;
UInt32 i; uint32_t i;
for (i = 0; i < index; i++) for (i = 0; i < index; i++)
sum += values[i]; sum += values[i];
return sum; return sum;
@ -332,15 +333,15 @@ static UInt64 GetSum(const UInt64 *values, UInt32 index)
#define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break; #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 uint64_t *packSizes,
ILookInStream *inStream, UInt64 startPos, ILookInStream *inStream, uint64_t startPos,
Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain, uint8_t *outBuffer, size_t outSize, ISzAlloc *allocMain,
Byte *tempBuf[]) uint8_t *tempBuf[])
{ {
UInt32 ci; uint32_t ci;
SizeT tempSizes[3] = { 0, 0, 0}; size_t tempSizes[3] = { 0, 0, 0};
SizeT tempSize3 = 0; size_t tempSize3 = 0;
Byte *tempBuf3 = 0; uint8_t *tempBuf3 = 0;
RINOK(CheckSupportedFolder(folder)); RINOK(CheckSupportedFolder(folder));
@ -348,25 +349,25 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
{ {
CSzCoderInfo *coder = &folder->Coders[ci]; CSzCoderInfo *coder = &folder->Coders[ci];
if (IS_MAIN_METHOD((UInt32)coder->MethodID)) if (IS_MAIN_METHOD((uint32_t)coder->MethodID))
{ {
UInt32 si = 0; uint32_t si = 0;
UInt64 offset; uint64_t offset;
UInt64 inSize; uint64_t inSize;
Byte *outBufCur = outBuffer; uint8_t *outBufCur = outBuffer;
SizeT outSizeCur = outSize; size_t outSizeCur = outSize;
if (folder->NumCoders == 4) if (folder->NumCoders == 4)
{ {
UInt32 indices[] = { 3, 2, 0 }; uint32_t indices[] = { 3, 2, 0 };
UInt64 unpackSize = folder->UnpackSizes[ci]; uint64_t unpackSize = folder->UnpackSizes[ci];
si = indices[ci]; si = indices[ci];
if (ci < 2) if (ci < 2)
{ {
Byte *temp; uint8_t *temp;
outSizeCur = (SizeT)unpackSize; outSizeCur = (size_t)unpackSize;
if (outSizeCur != unpackSize) if (outSizeCur != unpackSize)
return SZ_ERROR_MEM; return SZ_ERROR_MEM;
temp = (Byte *)IAlloc_Alloc(allocMain, outSizeCur); temp = (uint8_t *)IAlloc_Alloc(allocMain, outSizeCur);
if (temp == 0 && outSizeCur != 0) if (temp == 0 && outSizeCur != 0)
return SZ_ERROR_MEM; return SZ_ERROR_MEM;
outBufCur = tempBuf[1 - ci] = temp; outBufCur = tempBuf[1 - ci] = temp;
@ -377,7 +378,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
if (unpackSize > outSize) /* check it */ if (unpackSize > outSize) /* check it */
return SZ_ERROR_PARAM; return SZ_ERROR_PARAM;
tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize); tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize);
tempSize3 = outSizeCur = (SizeT)unpackSize; tempSize3 = outSizeCur = (size_t)unpackSize;
} }
else else
return SZ_ERROR_UNSUPPORTED; return SZ_ERROR_UNSUPPORTED;
@ -411,16 +412,16 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
} }
else if (coder->MethodID == k_BCJ2) else if (coder->MethodID == k_BCJ2)
{ {
UInt64 offset = GetSum(packSizes, 1); uint64_t offset = GetSum(packSizes, 1);
UInt64 s3Size = packSizes[1]; uint64_t s3Size = packSizes[1];
SRes res; SRes res;
if (ci != 3) if (ci != 3)
return SZ_ERROR_UNSUPPORTED; return SZ_ERROR_UNSUPPORTED;
RINOK(LookInStream_SeekTo(inStream, startPos + offset)); RINOK(LookInStream_SeekTo(inStream, startPos + offset));
tempSizes[2] = (SizeT)s3Size; tempSizes[2] = (size_t)s3Size;
if (tempSizes[2] != s3Size) if (tempSizes[2] != s3Size)
return SZ_ERROR_MEM; return SZ_ERROR_MEM;
tempBuf[2] = (Byte *)IAlloc_Alloc(allocMain, tempSizes[2]); tempBuf[2] = (uint8_t *)IAlloc_Alloc(allocMain, tempSizes[2]);
if (tempBuf[2] == 0 && tempSizes[2] != 0) if (tempBuf[2] == 0 && tempSizes[2] != 0)
return SZ_ERROR_MEM; return SZ_ERROR_MEM;
res = SzDecodeCopy(s3Size, inStream, tempBuf[2]); res = SzDecodeCopy(s3Size, inStream, tempBuf[2]);
@ -442,7 +443,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
{ {
case k_BCJ: case k_BCJ:
{ {
UInt32 state; uint32_t state;
x86_Convert_Init(state); x86_Convert_Init(state);
x86_Convert(outBuffer, outSize, 0, &state, 0); x86_Convert(outBuffer, outSize, 0, &state, 0);
break; break;
@ -456,14 +457,14 @@ static SRes SzFolder_Decode2(const CSzFolder *folder, const UInt64 *packSizes,
return SZ_OK; return SZ_OK;
} }
SRes SzFolder_Decode(const CSzFolder *folder, const UInt64 *packSizes, SRes SzFolder_Decode(const CSzFolder *folder, const uint64_t *packSizes,
ILookInStream *inStream, UInt64 startPos, ILookInStream *inStream, uint64_t startPos,
Byte *outBuffer, size_t outSize, ISzAlloc *allocMain) uint8_t *outBuffer, size_t outSize, ISzAlloc *allocMain)
{ {
Byte *tempBuf[3] = { 0, 0, 0}; uint8_t *tempBuf[3] = { 0, 0, 0};
int i; int i;
SRes res = SzFolder_Decode2(folder, packSizes, inStream, startPos, SRes res = SzFolder_Decode2(folder, packSizes, inStream, startPos,
outBuffer, (SizeT)outSize, allocMain, tempBuf); outBuffer, (size_t)outSize, allocMain, tempBuf);
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
IAlloc_Free(allocMain, tempBuf[i]); IAlloc_Free(allocMain, tempBuf[i]);
return res; return res;

13
deps/7zip/7zFile.c vendored

@ -1,6 +1,7 @@
/* 7zFile.c -- File IO /* 7zFile.c -- File IO
2009-11-24 : Igor Pavlov : Public domain */ 2009-11-24 : Igor Pavlov : Public domain */
#include <stdint.h>
#include "7zFile.h" #include "7zFile.h"
#ifndef USE_WINDOWS_FILE #ifndef USE_WINDOWS_FILE
@ -164,14 +165,14 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size)
#endif #endif
} }
WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin) WRes File_Seek(CSzFile *p, int64_t *pos, ESzSeek origin)
{ {
#ifdef USE_WINDOWS_FILE #ifdef USE_WINDOWS_FILE
LARGE_INTEGER value; LARGE_INTEGER value;
DWORD moveMethod; DWORD moveMethod;
value.LowPart = (DWORD)*pos; value.LowPart = (DWORD)*pos;
value.HighPart = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */ value.HighPart = (LONG)((uint64_t)*pos >> 16 >> 16); /* for case when uint64_t is 32-bit only */
switch (origin) switch (origin)
{ {
case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break; case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;
@ -186,7 +187,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
if (res != NO_ERROR) if (res != NO_ERROR)
return res; return res;
} }
*pos = ((Int64)value.HighPart << 32) | value.LowPart; *pos = ((int64_t)value.HighPart << 32) | value.LowPart;
return 0; return 0;
#else #else
@ -207,7 +208,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
#endif #endif
} }
WRes File_GetLength(CSzFile *p, UInt64 *length) WRes File_GetLength(CSzFile *p, uint64_t *length)
{ {
#ifdef USE_WINDOWS_FILE #ifdef USE_WINDOWS_FILE
@ -219,7 +220,7 @@ WRes File_GetLength(CSzFile *p, UInt64 *length)
if (res != NO_ERROR) if (res != NO_ERROR)
return res; return res;
} }
*length = (((UInt64)sizeHigh) << 32) + sizeLow; *length = (((uint64_t)sizeHigh) << 32) + sizeLow;
return 0; return 0;
#else #else
@ -256,7 +257,7 @@ static SRes FileInStream_Read(void *pp, void *buf, size_t *size)
return (File_Read(&p->file, buf, size) == 0) ? SZ_OK : SZ_ERROR_READ; return (File_Read(&p->file, buf, size) == 0) ? SZ_OK : SZ_ERROR_READ;
} }
static SRes FileInStream_Seek(void *pp, Int64 *pos, ESzSeek origin) static SRes FileInStream_Seek(void *pp, int64_t *pos, ESzSeek origin)
{ {
CFileInStream *p = (CFileInStream *)pp; CFileInStream *p = (CFileInStream *)pp;
return File_Seek(&p->file, pos, origin); return File_Seek(&p->file, pos, origin);

4
deps/7zip/7zFile.h vendored

@ -46,8 +46,8 @@ WRes File_Read(CSzFile *p, void *data, size_t *size);
/* writes *size bytes */ /* writes *size bytes */
WRes File_Write(CSzFile *p, const void *data, size_t *size); WRes File_Write(CSzFile *p, const void *data, size_t *size);
WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin); WRes File_Seek(CSzFile *p, int64_t *pos, ESzSeek origin);
WRes File_GetLength(CSzFile *p, UInt64 *length); WRes File_GetLength(CSzFile *p, uint64_t *length);
/* ---------- FileInStream ---------- */ /* ---------- FileInStream ---------- */

421
deps/7zip/7zIn.c vendored

File diff suppressed because it is too large Load Diff

14
deps/7zip/7zStream.c vendored

@ -1,6 +1,8 @@
/* 7zStream.c -- 7z Stream functions /* 7zStream.c -- 7z Stream functions
2010-03-11 : Igor Pavlov : Public domain */ 2010-03-11 : Igor Pavlov : Public domain */
#include <stdint.h>
#include <stdint.h>
#include <string.h> #include <string.h>
#include "Types.h" #include "Types.h"
@ -13,7 +15,7 @@ SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorT
RINOK(stream->Read(stream, buf, &processed)); RINOK(stream->Read(stream, buf, &processed));
if (processed == 0) if (processed == 0)
return errorType; return errorType;
buf = (void *)((Byte *)buf + processed); buf = (void *)((uint8_t *)buf + processed);
size -= processed; size -= processed;
} }
return SZ_OK; return SZ_OK;
@ -24,16 +26,16 @@ SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size)
return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF); return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
} }
SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf) SRes SeqInStream_Readuint8_t(ISeqInStream *stream, uint8_t *buf)
{ {
size_t processed = 1; size_t processed = 1;
RINOK(stream->Read(stream, buf, &processed)); RINOK(stream->Read(stream, buf, &processed));
return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF; return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;
} }
SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset) SRes LookInStream_SeekTo(ILookInStream *stream, uint64_t offset)
{ {
Int64 t = offset; int64_t t = offset;
return stream->Seek(stream, &t, SZ_SEEK_SET); return stream->Seek(stream, &t, SZ_SEEK_SET);
} }
@ -55,7 +57,7 @@ SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes erro
RINOK(stream->Read(stream, buf, &processed)); RINOK(stream->Read(stream, buf, &processed));
if (processed == 0) if (processed == 0)
return errorType; return errorType;
buf = (void *)((Byte *)buf + processed); buf = (void *)((uint8_t *)buf + processed);
size -= processed; size -= processed;
} }
return SZ_OK; return SZ_OK;
@ -124,7 +126,7 @@ static SRes LookToRead_Read(void *pp, void *buf, size_t *size)
return SZ_OK; return SZ_OK;
} }
static SRes LookToRead_Seek(void *pp, Int64 *pos, ESzSeek origin) static SRes LookToRead_Seek(void *pp, int64_t *pos, ESzSeek origin)
{ {
CLookToRead *p = (CLookToRead *)pp; CLookToRead *p = (CLookToRead *)pp;
p->pos = p->size = 0; p->pos = p->size = 0;

69
deps/7zip/Bcj2.c vendored

@ -1,19 +1,14 @@
/* Bcj2.c -- Converter for x86 code (BCJ2) /* Bcj2.c -- Converter for x86 code (BCJ2)
2008-10-04 : Igor Pavlov : Public domain */ 2008-10-04 : Igor Pavlov : Public domain */
#include <stdint.h>
#include "Bcj2.h" #include "Bcj2.h"
#ifdef _LZMA_PROB32
#define CProb UInt32
#else
#define CProb UInt16
#endif
#define IsJcc(b0, b1) ((b0) == 0x0F && ((b1) & 0xF0) == 0x80) #define IsJcc(b0, b1) ((b0) == 0x0F && ((b1) & 0xF0) == 0x80)
#define IsJ(b0, b1) ((b1 & 0xFE) == 0xE8 || IsJcc(b0, b1)) #define IsJ(b0, b1) ((b1 & 0xFE) == 0xE8 || IsJcc(b0, b1))
#define kNumTopBits 24 #define kNumTopBits 24
#define kTopValue ((UInt32)1 << kNumTopBits) #define kTopValue ((uint32_t)1 << kNumTopBits)
#define kNumBitModelTotalBits 11 #define kNumBitModelTotalBits 11
#define kBitModelTotal (1 << kNumBitModelTotalBits) #define kBitModelTotal (1 << kNumBitModelTotalBits)
@ -27,22 +22,22 @@
#define BCJ2_NORMALIZE if (range < kTopValue) { RC_TEST; range <<= 8; code = (code << 8) | RC_READ_BYTE; } #define BCJ2_NORMALIZE if (range < kTopValue) { RC_TEST; range <<= 8; code = (code << 8) | RC_READ_BYTE; }
#define BCJ2_IF_BIT_0(p) ttt = *(p); bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound) #define BCJ2_IF_BIT_0(p) ttt = *(p); bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
#define BCJ2_UPDATE_0(p) range = bound; *(p) = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); BCJ2_NORMALIZE; #define BCJ2_UPDATE_0(p) range = bound; *(p) = (uint16_t)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); BCJ2_NORMALIZE;
#define BCJ2_UPDATE_1(p) range -= bound; code -= bound; *(p) = (CProb)(ttt - (ttt >> kNumMoveBits)); BCJ2_NORMALIZE; #define BCJ2_UPDATE_1(p) range -= bound; code -= bound; *(p) = (uint16_t)(ttt - (ttt >> kNumMoveBits)); BCJ2_NORMALIZE;
int Bcj2_Decode( int Bcj2_Decode(
const Byte *buf0, SizeT size0, const uint8_t *buf0, size_t size0,
const Byte *buf1, SizeT size1, const uint8_t *buf1, size_t size1,
const Byte *buf2, SizeT size2, const uint8_t *buf2, size_t size2,
const Byte *buf3, SizeT size3, const uint8_t *buf3, size_t size3,
Byte *outBuf, SizeT outSize) uint8_t *outBuf, size_t outSize)
{ {
CProb p[256 + 2]; uint16_t p[256 + 2];
SizeT inPos = 0, outPos = 0; size_t inPos = 0, outPos = 0;
const Byte *buffer, *bufferLim; const uint8_t *buffer, *bufferLim;
UInt32 range, code; uint32_t range, code;
Byte prevByte = 0; uint8_t prevuint8_t = 0;
unsigned int i; unsigned int i;
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++) for (i = 0; i < sizeof(p) / sizeof(p[0]); i++)
@ -57,22 +52,22 @@ int Bcj2_Decode(
for (;;) for (;;)
{ {
Byte b; uint8_t b;
CProb *prob; uint16_t *prob;
UInt32 bound; uint32_t bound;
UInt32 ttt; uint32_t ttt;
SizeT limit = size0 - inPos; size_t limit = size0 - inPos;
if (outSize - outPos < limit) if (outSize - outPos < limit)
limit = outSize - outPos; limit = outSize - outPos;
while (limit != 0) while (limit != 0)
{ {
Byte b = buf0[inPos]; uint8_t b = buf0[inPos];
outBuf[outPos++] = b; outBuf[outPos++] = b;
if (IsJ(prevByte, b)) if (IsJ(prevuint8_t, b))
break; break;
inPos++; inPos++;
prevByte = b; prevuint8_t = b;
limit--; limit--;
} }
@ -82,7 +77,7 @@ int Bcj2_Decode(
b = buf0[inPos++]; b = buf0[inPos++];
if (b == 0xE8) if (b == 0xE8)
prob = p + prevByte; prob = p + prevuint8_t;
else if (b == 0xE9) else if (b == 0xE9)
prob = p + 256; prob = p + 256;
else else
@ -91,12 +86,12 @@ int Bcj2_Decode(
BCJ2_IF_BIT_0(prob) BCJ2_IF_BIT_0(prob)
{ {
BCJ2_UPDATE_0(prob) BCJ2_UPDATE_0(prob)
prevByte = b; prevuint8_t = b;
} }
else else
{ {
UInt32 dest; uint32_t dest;
const Byte *v; const uint8_t *v;
BCJ2_UPDATE_1(prob) BCJ2_UPDATE_1(prob)
if (b == 0xE8) if (b == 0xE8)
{ {
@ -114,18 +109,18 @@ int Bcj2_Decode(
buf2 += 4; buf2 += 4;
size2 -= 4; size2 -= 4;
} }
dest = (((UInt32)v[0] << 24) | ((UInt32)v[1] << 16) | dest = (((uint32_t)v[0] << 24) | ((uint32_t)v[1] << 16) |
((UInt32)v[2] << 8) | ((UInt32)v[3])) - ((UInt32)outPos + 4); ((uint32_t)v[2] << 8) | ((uint32_t)v[3])) - ((uint32_t)outPos + 4);
outBuf[outPos++] = (Byte)dest; outBuf[outPos++] = (uint8_t)dest;
if (outPos == outSize) if (outPos == outSize)
break; break;
outBuf[outPos++] = (Byte)(dest >> 8); outBuf[outPos++] = (uint8_t)(dest >> 8);
if (outPos == outSize) if (outPos == outSize)
break; break;
outBuf[outPos++] = (Byte)(dest >> 16); outBuf[outPos++] = (uint8_t)(dest >> 16);
if (outPos == outSize) if (outPos == outSize)
break; break;
outBuf[outPos++] = prevByte = (Byte)(dest >> 24); outBuf[outPos++] = prevuint8_t = (uint8_t)(dest >> 24);
} }
} }
return (outPos == outSize) ? SZ_OK : SZ_ERROR_DATA; return (outPos == outSize) ? SZ_OK : SZ_ERROR_DATA;

10
deps/7zip/Bcj2.h vendored

@ -25,11 +25,11 @@ Returns:
*/ */
int Bcj2_Decode( int Bcj2_Decode(
const Byte *buf0, SizeT size0, const uint8_t *buf0, size_t size0,
const Byte *buf1, SizeT size1, const uint8_t *buf1, size_t size1,
const Byte *buf2, SizeT size2, const uint8_t *buf2, size_t size2,
const Byte *buf3, SizeT size3, const uint8_t *buf3, size_t size3,
Byte *outBuf, SizeT outSize); uint8_t *outBuf, size_t outSize);
#ifdef __cplusplus #ifdef __cplusplus
} }

93
deps/7zip/Bra.c vendored

@ -1,11 +1,12 @@
/* Bra.c -- Converters for RISC code /* Bra.c -- Converters for RISC code
2010-04-16 : Igor Pavlov : Public domain */ 2010-04-16 : Igor Pavlov : Public domain */
#include <stdint.h>
#include "Bra.h" #include "Bra.h"
SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding) size_t ARM_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding)
{ {
SizeT i; size_t i;
if (size < 4) if (size < 4)
return 0; return 0;
size -= 4; size -= 4;
@ -14,25 +15,25 @@ SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
{ {
if (data[i + 3] == 0xEB) if (data[i + 3] == 0xEB)
{ {
UInt32 dest; uint32_t dest;
UInt32 src = ((UInt32)data[i + 2] << 16) | ((UInt32)data[i + 1] << 8) | (data[i + 0]); uint32_t src = ((uint32_t)data[i + 2] << 16) | ((uint32_t)data[i + 1] << 8) | (data[i + 0]);
src <<= 2; src <<= 2;
if (encoding) if (encoding)
dest = ip + (UInt32)i + src; dest = ip + (uint32_t)i + src;
else else
dest = src - (ip + (UInt32)i); dest = src - (ip + (uint32_t)i);
dest >>= 2; dest >>= 2;
data[i + 2] = (Byte)(dest >> 16); data[i + 2] = (uint8_t)(dest >> 16);
data[i + 1] = (Byte)(dest >> 8); data[i + 1] = (uint8_t)(dest >> 8);
data[i + 0] = (Byte)dest; data[i + 0] = (uint8_t)dest;
} }
} }
return i; return i;
} }
SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding) size_t ARMT_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding)
{ {
SizeT i; size_t i;
if (size < 4) if (size < 4)
return 0; return 0;
size -= 4; size -= 4;
@ -42,33 +43,33 @@ SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
if ((data[i + 1] & 0xF8) == 0xF0 && if ((data[i + 1] & 0xF8) == 0xF0 &&
(data[i + 3] & 0xF8) == 0xF8) (data[i + 3] & 0xF8) == 0xF8)
{ {
UInt32 dest; uint32_t dest;
UInt32 src = uint32_t src =
(((UInt32)data[i + 1] & 0x7) << 19) | (((uint32_t)data[i + 1] & 0x7) << 19) |
((UInt32)data[i + 0] << 11) | ((uint32_t)data[i + 0] << 11) |
(((UInt32)data[i + 3] & 0x7) << 8) | (((uint32_t)data[i + 3] & 0x7) << 8) |
(data[i + 2]); (data[i + 2]);
src <<= 1; src <<= 1;
if (encoding) if (encoding)
dest = ip + (UInt32)i + src; dest = ip + (uint32_t)i + src;
else else
dest = src - (ip + (UInt32)i); dest = src - (ip + (uint32_t)i);
dest >>= 1; dest >>= 1;
data[i + 1] = (Byte)(0xF0 | ((dest >> 19) & 0x7)); data[i + 1] = (uint8_t)(0xF0 | ((dest >> 19) & 0x7));
data[i + 0] = (Byte)(dest >> 11); data[i + 0] = (uint8_t)(dest >> 11);
data[i + 3] = (Byte)(0xF8 | ((dest >> 8) & 0x7)); data[i + 3] = (uint8_t)(0xF8 | ((dest >> 8) & 0x7));
data[i + 2] = (Byte)dest; data[i + 2] = (uint8_t)dest;
i += 2; i += 2;
} }
} }
return i; return i;
} }
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding) size_t PPC_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding)
{ {
SizeT i; size_t i;
if (size < 4) if (size < 4)
return 0; return 0;
size -= 4; size -= 4;
@ -76,19 +77,19 @@ SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
{ {
if ((data[i] >> 2) == 0x12 && (data[i + 3] & 3) == 1) if ((data[i] >> 2) == 0x12 && (data[i + 3] & 3) == 1)
{ {
UInt32 src = ((UInt32)(data[i + 0] & 3) << 24) | uint32_t src = ((uint32_t)(data[i + 0] & 3) << 24) |
((UInt32)data[i + 1] << 16) | ((uint32_t)data[i + 1] << 16) |
((UInt32)data[i + 2] << 8) | ((uint32_t)data[i + 2] << 8) |
((UInt32)data[i + 3] & (~3)); ((uint32_t)data[i + 3] & (~3));
UInt32 dest; uint32_t dest;
if (encoding) if (encoding)
dest = ip + (UInt32)i + src; dest = ip + (uint32_t)i + src;
else else
dest = src - (ip + (UInt32)i); dest = src - (ip + (uint32_t)i);
data[i + 0] = (Byte)(0x48 | ((dest >> 24) & 0x3)); data[i + 0] = (uint8_t)(0x48 | ((dest >> 24) & 0x3));
data[i + 1] = (Byte)(dest >> 16); data[i + 1] = (uint8_t)(dest >> 16);
data[i + 2] = (Byte)(dest >> 8); data[i + 2] = (uint8_t)(dest >> 8);
data[i + 3] &= 0x3; data[i + 3] &= 0x3;
data[i + 3] |= dest; data[i + 3] |= dest;
} }
@ -96,9 +97,9 @@ SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
return i; return i;
} }
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding) size_t SPARC_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding)
{ {
UInt32 i; uint32_t i;
if (size < 4) if (size < 4)
return 0; return 0;
size -= 4; size -= 4;
@ -107,12 +108,12 @@ SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
if ((data[i] == 0x40 && (data[i + 1] & 0xC0) == 0x00) || if ((data[i] == 0x40 && (data[i + 1] & 0xC0) == 0x00) ||
(data[i] == 0x7F && (data[i + 1] & 0xC0) == 0xC0)) (data[i] == 0x7F && (data[i + 1] & 0xC0) == 0xC0))
{ {
UInt32 src = uint32_t src =
((UInt32)data[i + 0] << 24) | ((uint32_t)data[i + 0] << 24) |
((UInt32)data[i + 1] << 16) | ((uint32_t)data[i + 1] << 16) |
((UInt32)data[i + 2] << 8) | ((uint32_t)data[i + 2] << 8) |
((UInt32)data[i + 3]); ((uint32_t)data[i + 3]);
UInt32 dest; uint32_t dest;
src <<= 2; src <<= 2;
if (encoding) if (encoding)
@ -123,10 +124,10 @@ SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
dest = (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000; dest = (((0 - ((dest >> 22) & 1)) << 22) & 0x3FFFFFFF) | (dest & 0x3FFFFF) | 0x40000000;
data[i + 0] = (Byte)(dest >> 24); data[i + 0] = (uint8_t)(dest >> 24);
data[i + 1] = (Byte)(dest >> 16); data[i + 1] = (uint8_t)(dest >> 16);
data[i + 2] = (Byte)(dest >> 8); data[i + 2] = (uint8_t)(dest >> 8);
data[i + 3] = (Byte)dest; data[i + 3] = (uint8_t)dest;
} }
} }
return i; return i;

16
deps/7zip/Bra.h vendored

@ -42,11 +42,11 @@ If (size < Alignment + LookAhead), converter returns 0.
Example: Example:
UInt32 ip = 0; uint32_t ip = 0;
for () for ()
{ {
; size must be >= Alignment + LookAhead, if it's not last block ; size must be >= Alignment + LookAhead, if it's not last block
SizeT processed = Convert(data, size, ip, 1); size_t processed = Convert(data, size, ip, 1);
data += processed; data += processed;
size -= processed; size -= processed;
ip += processed; ip += processed;
@ -54,12 +54,12 @@ ip += processed;
*/ */
#define x86_Convert_Init(state) { state = 0; } #define x86_Convert_Init(state) { state = 0; }
SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding); size_t x86_Convert(uint8_t *data, size_t size, uint32_t ip, uint32_t *state, int encoding);
SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); size_t ARM_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding);
SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); size_t ARMT_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding);
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); size_t PPC_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding);
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); size_t SPARC_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding);
SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding); size_t IA64_Convert(uint8_t *data, size_t size, uint32_t ip, int encoding);
#ifdef __cplusplus #ifdef __cplusplus
} }

49
deps/7zip/Bra86.c vendored

@ -1,30 +1,31 @@
/* Bra86.c -- Converter for x86 code (BCJ) /* Bra86.c -- Converter for x86 code (BCJ)
2008-10-04 : Igor Pavlov : Public domain */ 2008-10-04 : Igor Pavlov : Public domain */
#include <stdint.h>
#include "Bra.h" #include "Bra.h"
#define Test86MSByte(b) ((b) == 0 || (b) == 0xFF) #define Test86MSuint8_t(b) ((b) == 0 || (b) == 0xFF)
const Byte kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0}; const uint8_t kMaskToAllowedStatus[8] = {1, 1, 1, 0, 1, 0, 0, 0};
const Byte kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3}; const uint8_t kMaskToBitNumber[8] = {0, 1, 2, 2, 3, 3, 3, 3};
SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding) size_t x86_Convert(uint8_t *data, size_t size, uint32_t ip, uint32_t *state, int encoding)
{ {
SizeT bufferPos = 0, prevPosT; size_t bufferPos = 0, prevPosT;
UInt32 prevMask = *state & 0x7; uint32_t prevMask = *state & 0x7;
if (size < 5) if (size < 5)
return 0; return 0;
ip += 5; ip += 5;
prevPosT = (SizeT)0 - 1; prevPosT = (size_t)0 - 1;
for (;;) for (;;)
{ {
Byte *p = data + bufferPos; uint8_t *p = data + bufferPos;
Byte *limit = data + size - 4; uint8_t *limit = data + size - 4;
for (; p < limit; p++) for (; p < limit; p++)
if ((*p & 0xFE) == 0xE8) if ((*p & 0xFE) == 0xE8)
break; break;
bufferPos = (SizeT)(p - data); bufferPos = (size_t)(p - data);
if (p >= limit) if (p >= limit)
break; break;
prevPosT = bufferPos - prevPosT; prevPosT = bufferPos - prevPosT;
@ -35,8 +36,8 @@ SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding
prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7; prevMask = (prevMask << ((int)prevPosT - 1)) & 0x7;
if (prevMask != 0) if (prevMask != 0)
{ {
Byte b = p[4 - kMaskToBitNumber[prevMask]]; uint8_t b = p[4 - kMaskToBitNumber[prevMask]];
if (!kMaskToAllowedStatus[prevMask] || Test86MSByte(b)) if (!kMaskToAllowedStatus[prevMask] || Test86MSuint8_t(b))
{ {
prevPosT = bufferPos; prevPosT = bufferPos;
prevMask = ((prevMask << 1) & 0x7) | 1; prevMask = ((prevMask << 1) & 0x7) | 1;
@ -47,30 +48,30 @@ SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding
} }
prevPosT = bufferPos; prevPosT = bufferPos;
if (Test86MSByte(p[4])) if (Test86MSuint8_t(p[4]))
{ {
UInt32 src = ((UInt32)p[4] << 24) | ((UInt32)p[3] << 16) | ((UInt32)p[2] << 8) | ((UInt32)p[1]); uint32_t src = ((uint32_t)p[4] << 24) | ((uint32_t)p[3] << 16) | ((uint32_t)p[2] << 8) | ((uint32_t)p[1]);
UInt32 dest; uint32_t dest;
for (;;) for (;;)
{ {
Byte b; uint8_t b;
int index; int index;
if (encoding) if (encoding)
dest = (ip + (UInt32)bufferPos) + src; dest = (ip + (uint32_t)bufferPos) + src;
else else
dest = src - (ip + (UInt32)bufferPos); dest = src - (ip + (uint32_t)bufferPos);
if (prevMask == 0) if (prevMask == 0)
break; break;
index = kMaskToBitNumber[prevMask] * 8; index = kMaskToBitNumber[prevMask] * 8;
b = (Byte)(dest >> (24 - index)); b = (uint8_t)(dest >> (24 - index));
if (!Test86MSByte(b)) if (!Test86MSuint8_t(b))
break; break;
src = dest ^ ((1 << (32 - index)) - 1); src = dest ^ ((1 << (32 - index)) - 1);
} }
p[4] = (Byte)(~(((dest >> 24) & 1) - 1)); p[4] = (uint8_t)(~(((dest >> 24) & 1) - 1));
p[3] = (Byte)(dest >> 16); p[3] = (uint8_t)(dest >> 16);
p[2] = (Byte)(dest >> 8); p[2] = (uint8_t)(dest >> 8);
p[1] = (Byte)dest; p[1] = (uint8_t)dest;
bufferPos += 5; bufferPos += 5;
} }
else else

1
deps/7zip/CpuArch.c vendored

@ -1,3 +1,4 @@
#include <stdint.h>
#include "CpuArch.h" #include "CpuArch.h"
Bool CPU_Is_InOrder(void); Bool CPU_Is_InOrder(void);

62
deps/7zip/CpuArch.h vendored

@ -62,38 +62,38 @@ Stop_Compiling_Bad_Endian
#ifdef MY_CPU_LE_UNALIGN #ifdef MY_CPU_LE_UNALIGN
#define GetUi16(p) (*(const UInt16 *)(p)) #define GetUi16(p) (*(const uint16_t *)(p))
#define GetUi32(p) (*(const UInt32 *)(p)) #define GetUi32(p) (*(const uint32_t *)(p))
#define GetUi64(p) (*(const UInt64 *)(p)) #define GetUi64(p) (*(const uint64_t *)(p))
#define SetUi16(p, d) *(UInt16 *)(p) = (d); #define SetUi16(p, d) *(uint16_t *)(p) = (d);
#define SetUi32(p, d) *(UInt32 *)(p) = (d); #define SetUi32(p, d) *(uint32_t *)(p) = (d);
#define SetUi64(p, d) *(UInt64 *)(p) = (d); #define SetUi64(p, d) *(uint64_t *)(p) = (d);
#else #else
#define GetUi16(p) (((const Byte *)(p))[0] | ((UInt16)((const Byte *)(p))[1] << 8)) #define GetUi16(p) (((const uint8_t *)(p))[0] | ((uint16_t)((const uint8_t *)(p))[1] << 8))
#define GetUi32(p) ( \ #define GetUi32(p) ( \
((const Byte *)(p))[0] | \ ((const uint8_t *)(p))[0] | \
((UInt32)((const Byte *)(p))[1] << 8) | \ ((uint32_t)((const uint8_t *)(p))[1] << 8) | \
((UInt32)((const Byte *)(p))[2] << 16) | \ ((uint32_t)((const uint8_t *)(p))[2] << 16) | \
((UInt32)((const Byte *)(p))[3] << 24)) ((uint32_t)((const uint8_t *)(p))[3] << 24))
#define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32)) #define GetUi64(p) (GetUi32(p) | ((uint64_t)GetUi32(((const uint8_t *)(p)) + 4) << 32))
#define SetUi16(p, d) { UInt32 _x_ = (d); \ #define SetUi16(p, d) { uint32_t _x_ = (d); \
((Byte *)(p))[0] = (Byte)_x_; \ ((uint8_t *)(p))[0] = (uint8_t)_x_; \
((Byte *)(p))[1] = (Byte)(_x_ >> 8); } ((uint8_t *)(p))[1] = (uint8_t)(_x_ >> 8); }
#define SetUi32(p, d) { UInt32 _x_ = (d); \ #define SetUi32(p, d) { uint32_t _x_ = (d); \
((Byte *)(p))[0] = (Byte)_x_; \ ((uint8_t *)(p))[0] = (uint8_t)_x_; \
((Byte *)(p))[1] = (Byte)(_x_ >> 8); \ ((uint8_t *)(p))[1] = (uint8_t)(_x_ >> 8); \
((Byte *)(p))[2] = (Byte)(_x_ >> 16); \ ((uint8_t *)(p))[2] = (uint8_t)(_x_ >> 16); \
((Byte *)(p))[3] = (Byte)(_x_ >> 24); } ((uint8_t *)(p))[3] = (uint8_t)(_x_ >> 24); }
#define SetUi64(p, d) { UInt64 _x64_ = (d); \ #define SetUi64(p, d) { uint64_t _x64_ = (d); \
SetUi32(p, (UInt32)_x64_); \ SetUi32(p, (uint32_t)_x64_); \
SetUi32(((Byte *)(p)) + 4, (UInt32)(_x64_ >> 32)); } SetUi32(((uint8_t *)(p)) + 4, (uint32_t)(_x64_ >> 32)); }
#endif #endif
@ -101,22 +101,22 @@ Stop_Compiling_Bad_Endian
#pragma intrinsic(_byteswap_ulong) #pragma intrinsic(_byteswap_ulong)
#pragma intrinsic(_byteswap_uint64) #pragma intrinsic(_byteswap_uint64)
#define GetBe32(p) _byteswap_ulong(*(const UInt32 *)(const Byte *)(p)) #define GetBe32(p) _byteswap_ulong(*(const uint32_t *)(const uint8_t *)(p))
#define GetBe64(p) _byteswap_uint64(*(const UInt64 *)(const Byte *)(p)) #define GetBe64(p) _byteswap_uint64(*(const uint64_t *)(const uint8_t *)(p))
#else #else
#define GetBe32(p) ( \ #define GetBe32(p) ( \
((UInt32)((const Byte *)(p))[0] << 24) | \ ((uint32_t)((const uint8_t *)(p))[0] << 24) | \
((UInt32)((const Byte *)(p))[1] << 16) | \ ((uint32_t)((const uint8_t *)(p))[1] << 16) | \
((UInt32)((const Byte *)(p))[2] << 8) | \ ((uint32_t)((const uint8_t *)(p))[2] << 8) | \
((const Byte *)(p))[3] ) ((const uint8_t *)(p))[3] )
#define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4)) #define GetBe64(p) (((uint64_t)GetBe32(p) << 32) | GetBe32(((const uint8_t *)(p)) + 4))
#endif #endif
#define GetBe16(p) (((UInt16)((const Byte *)(p))[0] << 8) | ((const Byte *)(p))[1]) #define GetBe16(p) (((uint16_t)((const uint8_t *)(p))[0] << 8) | ((const uint8_t *)(p))[1])
Bool CPU_Is_InOrder(); Bool CPU_Is_InOrder();

89
deps/7zip/Lzma2Dec.c vendored

@ -1,12 +1,7 @@
/* Lzma2Dec.c -- LZMA2 Decoder /* Lzma2Dec.c -- LZMA2 Decoder
2009-05-03 : Igor Pavlov : Public domain */ 2009-05-03 : Igor Pavlov : Public domain */
/* #define SHOW_DEBUG_INFO */ #include <stdint.h>
#ifdef SHOW_DEBUG_INFO
#include <stdio.h>
#endif
#include <string.h> #include <string.h>
#include "Lzma2Dec.h" #include "Lzma2Dec.h"
@ -36,13 +31,9 @@
#define LZMA2_IS_THERE_PROP(mode) ((mode) >= 2) #define LZMA2_IS_THERE_PROP(mode) ((mode) >= 2)
#define LZMA2_LCLP_MAX 4 #define LZMA2_LCLP_MAX 4
#define LZMA2_DIC_SIZE_FROM_PROP(p) (((UInt32)2 | ((p) & 1)) << ((p) / 2 + 11)) #define LZMA2_DIC_SIZE_FROM_PROP(p) (((uint32_t)2 | ((p) & 1)) << ((p) / 2 + 11))
#ifdef SHOW_DEBUG_INFO
#define PRF(x) x
#else
#define PRF(x) #define PRF(x)
#endif
typedef enum typedef enum
{ {
@ -58,30 +49,30 @@ typedef enum
LZMA2_STATE_ERROR LZMA2_STATE_ERROR
} ELzma2State; } ELzma2State;
static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props) static SRes Lzma2Dec_GetOldProps(uint8_t prop, uint8_t *props)
{ {
UInt32 dicSize; uint32_t dicSize;
if (prop > 40) if (prop > 40)
return SZ_ERROR_UNSUPPORTED; return SZ_ERROR_UNSUPPORTED;
dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop); dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);
props[0] = (Byte)LZMA2_LCLP_MAX; props[0] = (uint8_t)LZMA2_LCLP_MAX;
props[1] = (Byte)(dicSize); props[1] = (uint8_t)(dicSize);
props[2] = (Byte)(dicSize >> 8); props[2] = (uint8_t)(dicSize >> 8);
props[3] = (Byte)(dicSize >> 16); props[3] = (uint8_t)(dicSize >> 16);
props[4] = (Byte)(dicSize >> 24); props[4] = (uint8_t)(dicSize >> 24);
return SZ_OK; return SZ_OK;
} }
SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc) SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, uint8_t prop, ISzAlloc *alloc)
{ {
Byte props[LZMA_PROPS_SIZE]; uint8_t props[LZMA_PROPS_SIZE];
RINOK(Lzma2Dec_GetOldProps(prop, props)); RINOK(Lzma2Dec_GetOldProps(prop, props));
return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc); return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
} }
SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc) SRes Lzma2Dec_Allocate(CLzma2Dec *p, uint8_t prop, ISzAlloc *alloc)
{ {
Byte props[LZMA_PROPS_SIZE]; uint8_t props[LZMA_PROPS_SIZE];
RINOK(Lzma2Dec_GetOldProps(prop, props)); RINOK(Lzma2Dec_GetOldProps(prop, props));
return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc); return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
} }
@ -95,7 +86,7 @@ void Lzma2Dec_Init(CLzma2Dec *p)
LzmaDec_Init(&p->decoder); LzmaDec_Init(&p->decoder);
} }
static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b) static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, uint8_t b)
{ {
switch(p->state) switch(p->state)
{ {
@ -112,25 +103,25 @@ static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
p->unpackSize = 0; p->unpackSize = 0;
} }
else else
p->unpackSize = (UInt32)(p->control & 0x1F) << 16; p->unpackSize = (uint32_t)(p->control & 0x1F) << 16;
return LZMA2_STATE_UNPACK0; return LZMA2_STATE_UNPACK0;
case LZMA2_STATE_UNPACK0: case LZMA2_STATE_UNPACK0:
p->unpackSize |= (UInt32)b << 8; p->unpackSize |= (uint32_t)b << 8;
return LZMA2_STATE_UNPACK1; return LZMA2_STATE_UNPACK1;
case LZMA2_STATE_UNPACK1: case LZMA2_STATE_UNPACK1:
p->unpackSize |= (UInt32)b; p->unpackSize |= (uint32_t)b;
p->unpackSize++; p->unpackSize++;
PRF(printf(" %8d", p->unpackSize)); PRF(printf(" %8d", p->unpackSize));
return (LZMA2_IS_UNCOMPRESSED_STATE(p)) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0; return (LZMA2_IS_UNCOMPRESSED_STATE(p)) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0;
case LZMA2_STATE_PACK0: case LZMA2_STATE_PACK0:
p->packSize = (UInt32)b << 8; p->packSize = (uint32_t)b << 8;
return LZMA2_STATE_PACK1; return LZMA2_STATE_PACK1;
case LZMA2_STATE_PACK1: case LZMA2_STATE_PACK1:
p->packSize |= (UInt32)b; p->packSize |= (uint32_t)b;
p->packSize++; p->packSize++;
PRF(printf(" %8d", p->packSize)); PRF(printf(" %8d", p->packSize));
return LZMA2_IS_THERE_PROP(LZMA2_GET_LZMA_MODE(p)) ? LZMA2_STATE_PROP: return LZMA2_IS_THERE_PROP(LZMA2_GET_LZMA_MODE(p)) ? LZMA2_STATE_PROP:
@ -156,27 +147,27 @@ static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
return LZMA2_STATE_ERROR; return LZMA2_STATE_ERROR;
} }
static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size) static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const uint8_t *src, size_t size)
{ {
memcpy(p->dic + p->dicPos, src, size); memcpy(p->dic + p->dicPos, src, size);
p->dicPos += size; p->dicPos += size;
if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size) if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)
p->checkDicSize = p->prop.dicSize; p->checkDicSize = p->prop.dicSize;
p->processedPos += (UInt32)size; p->processedPos += (uint32_t)size;
} }
void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState); void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState);
SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit, SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, size_t dicLimit,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) const uint8_t *src, size_t *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
{ {
SizeT inSize = *srcLen; size_t inSize = *srcLen;
*srcLen = 0; *srcLen = 0;
*status = LZMA_STATUS_NOT_SPECIFIED; *status = LZMA_STATUS_NOT_SPECIFIED;
while (p->state != LZMA2_STATE_FINISHED) while (p->state != LZMA2_STATE_FINISHED)
{ {
SizeT dicPos = p->decoder.dicPos; size_t dicPos = p->decoder.dicPos;
if (p->state == LZMA2_STATE_ERROR) if (p->state == LZMA2_STATE_ERROR)
return SZ_ERROR_DATA; return SZ_ERROR_DATA;
if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY) if (dicPos == dicLimit && finishMode == LZMA_FINISH_ANY)
@ -196,13 +187,13 @@ SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
continue; continue;
} }
{ {
SizeT destSizeCur = dicLimit - dicPos; size_t destSizeCur = dicLimit - dicPos;
SizeT srcSizeCur = inSize - *srcLen; size_t srcSizeCur = inSize - *srcLen;
ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY; ELzmaFinishMode curFinishMode = LZMA_FINISH_ANY;
if (p->unpackSize <= destSizeCur) if (p->unpackSize <= destSizeCur)
{ {
destSizeCur = (SizeT)p->unpackSize; destSizeCur = (size_t)p->unpackSize;
curFinishMode = LZMA_FINISH_END; curFinishMode = LZMA_FINISH_END;
} }
@ -235,12 +226,12 @@ SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
src += srcSizeCur; src += srcSizeCur;
*srcLen += srcSizeCur; *srcLen += srcSizeCur;
p->unpackSize -= (UInt32)srcSizeCur; p->unpackSize -= (uint32_t)srcSizeCur;
p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT; p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
} }
else else
{ {
SizeT outSizeProcessed; size_t outSizeProcessed;
SRes res; SRes res;
if (p->state == LZMA2_STATE_DATA) if (p->state == LZMA2_STATE_DATA)
@ -257,16 +248,16 @@ SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
p->state = LZMA2_STATE_DATA_CONT; p->state = LZMA2_STATE_DATA_CONT;
} }
if (srcSizeCur > p->packSize) if (srcSizeCur > p->packSize)
srcSizeCur = (SizeT)p->packSize; srcSizeCur = (size_t)p->packSize;
res = LzmaDec_DecodeToDic(&p->decoder, dicPos + destSizeCur, src, &srcSizeCur, curFinishMode, status); res = LzmaDec_DecodeToDic(&p->decoder, dicPos + destSizeCur, src, &srcSizeCur, curFinishMode, status);
src += srcSizeCur; src += srcSizeCur;
*srcLen += srcSizeCur; *srcLen += srcSizeCur;
p->packSize -= (UInt32)srcSizeCur; p->packSize -= (uint32_t)srcSizeCur;
outSizeProcessed = p->decoder.dicPos - dicPos; outSizeProcessed = p->decoder.dicPos - dicPos;
p->unpackSize -= (UInt32)outSizeProcessed; p->unpackSize -= (uint32_t)outSizeProcessed;
RINOK(res); RINOK(res);
if (*status == LZMA_STATUS_NEEDS_MORE_INPUT) if (*status == LZMA_STATUS_NEEDS_MORE_INPUT)
@ -288,13 +279,13 @@ SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
return SZ_OK; return SZ_OK;
} }
SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, uint8_t *dest, size_t *destLen, const uint8_t *src, size_t *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
{ {
SizeT outSize = *destLen, inSize = *srcLen; size_t outSize = *destLen, inSize = *srcLen;
*srcLen = *destLen = 0; *srcLen = *destLen = 0;
for (;;) for (;;)
{ {
SizeT srcSizeCur = inSize, outSizeCur, dicPos; size_t srcSizeCur = inSize, outSizeCur, dicPos;
ELzmaFinishMode curFinishMode; ELzmaFinishMode curFinishMode;
SRes res; SRes res;
if (p->decoder.dicPos == p->decoder.dicBufSize) if (p->decoder.dicPos == p->decoder.dicBufSize)
@ -327,13 +318,13 @@ SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *
} }
} }
SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, SRes Lzma2Decode(uint8_t *dest, size_t *destLen, const uint8_t *src, size_t *srcLen,
Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc) uint8_t prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc)
{ {
CLzma2Dec decoder; CLzma2Dec decoder;
SRes res; SRes res;
SizeT outSize = *destLen, inSize = *srcLen; size_t outSize = *destLen, inSize = *srcLen;
Byte props[LZMA_PROPS_SIZE]; uint8_t props[LZMA_PROPS_SIZE];
Lzma2Dec_Construct(&decoder); Lzma2Dec_Construct(&decoder);

22
deps/7zip/Lzma2Dec.h vendored

@ -15,10 +15,10 @@ extern "C" {
typedef struct typedef struct
{ {
CLzmaDec decoder; CLzmaDec decoder;
UInt32 packSize; uint32_t packSize;
UInt32 unpackSize; uint32_t unpackSize;
int state; int state;
Byte control; uint8_t control;
Bool needInitDic; Bool needInitDic;
Bool needInitState; Bool needInitState;
Bool needInitProp; Bool needInitProp;
@ -28,8 +28,8 @@ typedef struct
#define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc); #define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc);
#define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc); #define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc);
SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc); SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, uint8_t prop, ISzAlloc *alloc);
SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc); SRes Lzma2Dec_Allocate(CLzma2Dec *p, uint8_t prop, ISzAlloc *alloc);
void Lzma2Dec_Init(CLzma2Dec *p); void Lzma2Dec_Init(CLzma2Dec *p);
@ -48,11 +48,11 @@ Returns:
SZ_ERROR_DATA - Data error SZ_ERROR_DATA - Data error
*/ */
SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit, SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, size_t dicLimit,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); const uint8_t *src, size_t *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, uint8_t *dest, size_t *destLen,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); const uint8_t *src, size_t *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
/* ---------- One Call Interface ---------- */ /* ---------- One Call Interface ---------- */
@ -74,8 +74,8 @@ Returns:
SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src). SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
*/ */
SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, SRes Lzma2Decode(uint8_t *dest, size_t *destLen, const uint8_t *src, size_t *srcLen,
Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc); uint8_t prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc);
#ifdef __cplusplus #ifdef __cplusplus
} }

167
deps/7zip/LzmaDec.c vendored

@ -1,12 +1,13 @@
/* LzmaDec.c -- LZMA Decoder /* LzmaDec.c -- LZMA Decoder
2009-09-20 : Igor Pavlov : Public domain */ 2009-09-20 : Igor Pavlov : Public domain */
#include <stdint.h>
#include <string.h>
#include "LzmaDec.h" #include "LzmaDec.h"
#include <string.h>
#define kNumTopBits 24 #define kNumTopBits 24
#define kTopValue ((UInt32)1 << kNumTopBits) #define kTopValue ((uint32_t)1 << kNumTopBits)
#define kNumBitModelTotalBits 11 #define kNumBitModelTotalBits 11
#define kBitModelTotal (1 << kNumBitModelTotalBits) #define kBitModelTotal (1 << kNumBitModelTotalBits)
@ -17,8 +18,8 @@
#define LZMADEC_NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); } #define LZMADEC_NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
#define LZMADEC_IF_BIT_0(p) ttt = *(p); LZMADEC_NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound) #define LZMADEC_IF_BIT_0(p) ttt = *(p); LZMADEC_NORMALIZE; bound = (range >> kNumBitModelTotalBits) * ttt; if (code < bound)
#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits)); #define UPDATE_0(p) range = bound; *(p) = (uint16_t)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
#define LZMADEC_UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits)); #define LZMADEC_UPDATE_1(p) range -= bound; code -= bound; *(p) = (uint16_t)(ttt - (ttt >> kNumMoveBits));
#define GET_BIT2(p, i, A0, A1) LZMADEC_IF_BIT_0(p) \ #define GET_BIT2(p, i, A0, A1) LZMADEC_IF_BIT_0(p) \
{ UPDATE_0(p); i = (i + i); A0; } else \ { UPDATE_0(p); i = (i + i); A0; } else \
{ LZMADEC_UPDATE_1(p); i = (i + i) + 1; A1; } { LZMADEC_UPDATE_1(p); i = (i + i) + 1; A1; }
@ -107,7 +108,7 @@
#define LZMA_BASE_SIZE 1846 #define LZMA_BASE_SIZE 1846
#define LZMA_LIT_SIZE 768 #define LZMA_LIT_SIZE 768
#define LzmaProps_GetNumProbs(p) ((UInt32)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp))) #define LzmaProps_GetNumProbs(p) ((uint32_t)LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
#if Literal != LZMA_BASE_SIZE #if Literal != LZMA_BASE_SIZE
StopCompilingDueBUG StopCompilingDueBUG
@ -128,32 +129,32 @@ StopCompilingDueBUG
= kMatchSpecLenStart + 2 : State Init Marker = kMatchSpecLenStart + 2 : State Init Marker
*/ */
static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit) static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, size_t limit, const uint8_t *bufLimit)
{ {
CLzmaProb *probs = p->probs; uint16_t *probs = p->probs;
unsigned state = p->state; unsigned state = p->state;
UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3]; uint32_t rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1; unsigned pbMask = ((unsigned)1 << (p->prop.pb)) - 1;
unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1; unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
unsigned lc = p->prop.lc; unsigned lc = p->prop.lc;
Byte *dic = p->dic; uint8_t *dic = p->dic;
SizeT dicBufSize = p->dicBufSize; size_t dicBufSize = p->dicBufSize;
SizeT dicPos = p->dicPos; size_t dicPos = p->dicPos;
UInt32 processedPos = p->processedPos; uint32_t processedPos = p->processedPos;
UInt32 checkDicSize = p->checkDicSize; uint32_t checkDicSize = p->checkDicSize;
unsigned len = 0; unsigned len = 0;
const Byte *buf = p->buf; const uint8_t *buf = p->buf;
UInt32 range = p->range; uint32_t range = p->range;
UInt32 code = p->code; uint32_t code = p->code;
do do
{ {
CLzmaProb *prob; uint16_t *prob;
UInt32 bound; uint32_t bound;
unsigned ttt; unsigned ttt;
unsigned posState = processedPos & pbMask; unsigned posState = processedPos & pbMask;
@ -175,22 +176,22 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
} }
else else
{ {
unsigned matchByte = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)]; unsigned matchuint8_t = p->dic[(dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0)];
unsigned offs = 0x100; unsigned offs = 0x100;
state -= (state < 10) ? 3 : 6; state -= (state < 10) ? 3 : 6;
symbol = 1; symbol = 1;
do do
{ {
unsigned bit; unsigned bit;
CLzmaProb *probLit; uint16_t *probLit;
matchByte <<= 1; matchuint8_t <<= 1;
bit = (matchByte & offs); bit = (matchuint8_t & offs);
probLit = prob + offs + bit + symbol; probLit = prob + offs + bit + symbol;
GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit) GET_BIT2(probLit, symbol, offs &= ~bit, offs &= bit)
} }
while (symbol < 0x100); while (symbol < 0x100);
} }
dic[dicPos++] = (Byte)symbol; dic[dicPos++] = (uint8_t)symbol;
processedPos++; processedPos++;
continue; continue;
} }
@ -227,7 +228,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
} }
else else
{ {
UInt32 distance; uint32_t distance;
LZMADEC_UPDATE_1(prob); LZMADEC_UPDATE_1(prob);
prob = probs + IsRepG1 + state; prob = probs + IsRepG1 + state;
LZMADEC_IF_BIT_0(prob) LZMADEC_IF_BIT_0(prob)
@ -260,7 +261,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
} }
{ {
unsigned limit, offset; unsigned limit, offset;
CLzmaProb *probLen = prob + LenChoice; uint16_t *probLen = prob + LenChoice;
LZMADEC_IF_BIT_0(probLen) LZMADEC_IF_BIT_0(probLen)
{ {
UPDATE_0(probLen); UPDATE_0(probLen);
@ -293,7 +294,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
if (state >= kNumStates) if (state >= kNumStates)
{ {
UInt32 distance; uint32_t distance;
prob = probs + PosSlot + prob = probs + PosSlot +
((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits); ((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
TREE_6_DECODE(prob, distance); TREE_6_DECODE(prob, distance);
@ -307,7 +308,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
distance <<= numDirectBits; distance <<= numDirectBits;
prob = probs + SpecPos + distance - posSlot - 1; prob = probs + SpecPos + distance - posSlot - 1;
{ {
UInt32 mask = 1; uint32_t mask = 1;
unsigned i = 1; unsigned i = 1;
do do
{ {
@ -326,9 +327,9 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
range >>= 1; range >>= 1;
{ {
UInt32 t; uint32_t t;
code -= range; code -= range;
t = (0 - ((UInt32)code >> 31)); /* (UInt32)((Int32)code >> 31) */ t = (0 - ((uint32_t)code >> 31)); /* (uint32_t)((Int32)code >> 31) */
distance = (distance << 1) + (t + 1); distance = (distance << 1) + (t + 1);
code += range & t; code += range & t;
} }
@ -351,7 +352,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
GET_BIT2(prob + i, i, ; , distance |= 4); GET_BIT2(prob + i, i, ; , distance |= 4);
GET_BIT2(prob + i, i, ; , distance |= 8); GET_BIT2(prob + i, i, ; , distance |= 8);
} }
if (distance == (UInt32)0xFFFFFFFF) if (distance == (uint32_t)0xFFFFFFFF)
{ {
len += kMatchSpecLenStart; len += kMatchSpecLenStart;
state -= kNumStates; state -= kNumStates;
@ -378,21 +379,21 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
if (limit == dicPos) if (limit == dicPos)
return SZ_ERROR_DATA; return SZ_ERROR_DATA;
{ {
SizeT rem = limit - dicPos; size_t rem = limit - dicPos;
unsigned curLen = ((rem < len) ? (unsigned)rem : len); unsigned curLen = ((rem < len) ? (unsigned)rem : len);
SizeT pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0); size_t pos = (dicPos - rep0) + ((dicPos < rep0) ? dicBufSize : 0);
processedPos += curLen; processedPos += curLen;
len -= curLen; len -= curLen;
if (pos + curLen <= dicBufSize) if (pos + curLen <= dicBufSize)
{ {
Byte *dest = dic + dicPos; uint8_t *dest = dic + dicPos;
ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos; ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
const Byte *lim = dest + curLen; const uint8_t *lim = dest + curLen;
dicPos += curLen; dicPos += curLen;
do do
*(dest) = (Byte)*(dest + src); *(dest) = (uint8_t)*(dest + src);
while (++dest != lim); while (++dest != lim);
} }
else else
@ -425,15 +426,15 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
return SZ_OK; return SZ_OK;
} }
static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit) static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, size_t limit)
{ {
if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart) if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
{ {
Byte *dic = p->dic; uint8_t *dic = p->dic;
SizeT dicPos = p->dicPos; size_t dicPos = p->dicPos;
SizeT dicBufSize = p->dicBufSize; size_t dicBufSize = p->dicBufSize;
unsigned len = p->remainLen; unsigned len = p->remainLen;
UInt32 rep0 = p->reps[0]; uint32_t rep0 = p->reps[0];
if (limit - dicPos < len) if (limit - dicPos < len)
len = (unsigned)(limit - dicPos); len = (unsigned)(limit - dicPos);
@ -451,14 +452,14 @@ static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
} }
} }
static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit) static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, size_t limit, const uint8_t *bufLimit)
{ {
do do
{ {
SizeT limit2 = limit; size_t limit2 = limit;
if (p->checkDicSize == 0) if (p->checkDicSize == 0)
{ {
UInt32 rem = p->prop.dicSize - p->processedPos; uint32_t rem = p->prop.dicSize - p->processedPos;
if (limit - p->dicPos > rem) if (limit - p->dicPos > rem)
limit2 = p->dicPos + rem; limit2 = p->dicPos + rem;
} }
@ -484,18 +485,18 @@ typedef enum
DUMMY_REP DUMMY_REP
} ELzmaDummy; } ELzmaDummy;
static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize) static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const uint8_t *buf, size_t inSize)
{ {
UInt32 range = p->range; uint32_t range = p->range;
UInt32 code = p->code; uint32_t code = p->code;
const Byte *bufLimit = buf + inSize; const uint8_t *bufLimit = buf + inSize;
CLzmaProb *probs = p->probs; uint16_t *probs = p->probs;
unsigned state = p->state; unsigned state = p->state;
ELzmaDummy res; ELzmaDummy res;
{ {
CLzmaProb *prob; uint16_t *prob;
UInt32 bound; uint32_t bound;
unsigned ttt; unsigned ttt;
unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1); unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
@ -519,16 +520,16 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
} }
else else
{ {
unsigned matchByte = p->dic[p->dicPos - p->reps[0] + unsigned matchuint8_t = p->dic[p->dicPos - p->reps[0] +
((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)]; ((p->dicPos < p->reps[0]) ? p->dicBufSize : 0)];
unsigned offs = 0x100; unsigned offs = 0x100;
unsigned symbol = 1; unsigned symbol = 1;
do do
{ {
unsigned bit; unsigned bit;
CLzmaProb *probLit; uint16_t *probLit;
matchByte <<= 1; matchuint8_t <<= 1;
bit = (matchByte & offs); bit = (matchuint8_t & offs);
probLit = prob + offs + bit + symbol; probLit = prob + offs + bit + symbol;
GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit) GET_BIT2_CHECK(probLit, symbol, offs &= ~bit, offs &= bit)
} }
@ -596,7 +597,7 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
} }
{ {
unsigned limit, offset; unsigned limit, offset;
CLzmaProb *probLen = prob + LenChoice; uint16_t *probLen = prob + LenChoice;
IF_BIT_0_CHECK(probLen) IF_BIT_0_CHECK(probLen)
{ {
UPDATE_0_CHECK; UPDATE_0_CHECK;
@ -675,9 +676,9 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
} }
static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data) static void LzmaDec_InitRc(CLzmaDec *p, const uint8_t *data)
{ {
p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]); p->code = ((uint32_t)data[1] << 24) | ((uint32_t)data[2] << 16) | ((uint32_t)data[3] << 8) | ((uint32_t)data[4]);
p->range = 0xFFFFFFFF; p->range = 0xFFFFFFFF;
p->needFlush = 0; p->needFlush = 0;
} }
@ -708,9 +709,9 @@ void LzmaDec_Init(CLzmaDec *p)
static void LzmaDec_InitStateReal(CLzmaDec *p) static void LzmaDec_InitStateReal(CLzmaDec *p)
{ {
UInt32 numProbs = Literal + ((UInt32)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp)); uint32_t numProbs = Literal + ((uint32_t)LZMA_LIT_SIZE << (p->prop.lc + p->prop.lp));
UInt32 i; uint32_t i;
CLzmaProb *probs = p->probs; uint16_t *probs = p->probs;
for (i = 0; i < numProbs; i++) for (i = 0; i < numProbs; i++)
probs[i] = kBitModelTotal >> 1; probs[i] = kBitModelTotal >> 1;
p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1; p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
@ -718,10 +719,10 @@ static void LzmaDec_InitStateReal(CLzmaDec *p)
p->needInitState = 0; p->needInitState = 0;
} }
SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen, SRes LzmaDec_DecodeToDic(CLzmaDec *p, size_t dicLimit, const uint8_t *src, size_t *srcLen,
ELzmaFinishMode finishMode, ELzmaStatus *status) ELzmaFinishMode finishMode, ELzmaStatus *status)
{ {
SizeT inSize = *srcLen; size_t inSize = *srcLen;
(*srcLen) = 0; (*srcLen) = 0;
LzmaDec_WriteRem(p, dicLimit); LzmaDec_WriteRem(p, dicLimit);
@ -773,8 +774,8 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
if (p->tempBufSize == 0) if (p->tempBufSize == 0)
{ {
SizeT processed; size_t processed;
const Byte *bufLimit; const uint8_t *bufLimit;
if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow) if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
{ {
int dummyRes = LzmaDec_TryDummy(p, src, inSize); int dummyRes = LzmaDec_TryDummy(p, src, inSize);
@ -798,7 +799,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
p->buf = src; p->buf = src;
if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0) if (LzmaDec_DecodeReal2(p, dicLimit, bufLimit) != 0)
return SZ_ERROR_DATA; return SZ_ERROR_DATA;
processed = (SizeT)(p->buf - src); processed = (size_t)(p->buf - src);
(*srcLen) += processed; (*srcLen) += processed;
src += processed; src += processed;
inSize -= processed; inSize -= processed;
@ -839,14 +840,14 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA; return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
} }
SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status) SRes LzmaDec_DecodeToBuf(CLzmaDec *p, uint8_t *dest, size_t *destLen, const uint8_t *src, size_t *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
{ {
SizeT outSize = *destLen; size_t outSize = *destLen;
SizeT inSize = *srcLen; size_t inSize = *srcLen;
*srcLen = *destLen = 0; *srcLen = *destLen = 0;
for (;;) for (;;)
{ {
SizeT inSizeCur = inSize, outSizeCur, dicPos; size_t inSizeCur = inSize, outSizeCur, dicPos;
ELzmaFinishMode curFinishMode; ELzmaFinishMode curFinishMode;
SRes res; SRes res;
if (p->dicPos == p->dicBufSize) if (p->dicPos == p->dicBufSize)
@ -897,15 +898,15 @@ void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
LzmaDec_FreeDict(p, alloc); LzmaDec_FreeDict(p, alloc);
} }
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size) SRes LzmaProps_Decode(CLzmaProps *p, const uint8_t *data, unsigned size)
{ {
UInt32 dicSize; uint32_t dicSize;
Byte d; uint8_t d;
if (size < LZMA_PROPS_SIZE) if (size < LZMA_PROPS_SIZE)
return SZ_ERROR_UNSUPPORTED; return SZ_ERROR_UNSUPPORTED;
else else
dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24); dicSize = data[1] | ((uint32_t)data[2] << 8) | ((uint32_t)data[3] << 16) | ((uint32_t)data[4] << 24);
if (dicSize < LZMA_DIC_MIN) if (dicSize < LZMA_DIC_MIN)
dicSize = LZMA_DIC_MIN; dicSize = LZMA_DIC_MIN;
@ -925,11 +926,11 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc) static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)
{ {
UInt32 numProbs = LzmaProps_GetNumProbs(propNew); uint32_t numProbs = LzmaProps_GetNumProbs(propNew);
if (p->probs == 0 || numProbs != p->numProbs) if (p->probs == 0 || numProbs != p->numProbs)
{ {
LzmaDec_FreeProbs(p, alloc); LzmaDec_FreeProbs(p, alloc);
p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb)); p->probs = (uint16_t *)alloc->Alloc(alloc, numProbs * sizeof(uint16_t));
p->numProbs = numProbs; p->numProbs = numProbs;
if (p->probs == 0) if (p->probs == 0)
return SZ_ERROR_MEM; return SZ_ERROR_MEM;
@ -937,7 +938,7 @@ static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAl
return SZ_OK; return SZ_OK;
} }
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc) SRes LzmaDec_AllocateProbs(CLzmaDec *p, const uint8_t *props, unsigned propsSize, ISzAlloc *alloc)
{ {
CLzmaProps propNew; CLzmaProps propNew;
RINOK(LzmaProps_Decode(&propNew, props, propsSize)); RINOK(LzmaProps_Decode(&propNew, props, propsSize));
@ -946,17 +947,17 @@ SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, I
return SZ_OK; return SZ_OK;
} }
SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc) SRes LzmaDec_Allocate(CLzmaDec *p, const uint8_t *props, unsigned propsSize, ISzAlloc *alloc)
{ {
CLzmaProps propNew; CLzmaProps propNew;
SizeT dicBufSize; size_t dicBufSize;
RINOK(LzmaProps_Decode(&propNew, props, propsSize)); RINOK(LzmaProps_Decode(&propNew, props, propsSize));
RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc)); RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
dicBufSize = propNew.dicSize; dicBufSize = propNew.dicSize;
if (p->dic == 0 || dicBufSize != p->dicBufSize) if (p->dic == 0 || dicBufSize != p->dicBufSize)
{ {
LzmaDec_FreeDict(p, alloc); LzmaDec_FreeDict(p, alloc);
p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize); p->dic = (uint8_t *)alloc->Alloc(alloc, dicBufSize);
if (p->dic == 0) if (p->dic == 0)
{ {
LzmaDec_FreeProbs(p, alloc); LzmaDec_FreeProbs(p, alloc);
@ -968,14 +969,14 @@ SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAll
return SZ_OK; return SZ_OK;
} }
SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, SRes LzmaDecode(uint8_t *dest, size_t *destLen, const uint8_t *src, size_t *srcLen,
const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode, const uint8_t *propData, unsigned propSize, ELzmaFinishMode finishMode,
ELzmaStatus *status, ISzAlloc *alloc) ELzmaStatus *status, ISzAlloc *alloc)
{ {
CLzmaDec p; CLzmaDec p;
SRes res; SRes res;
SizeT inSize = *srcLen; size_t inSize = *srcLen;
SizeT outSize = *destLen; size_t outSize = *destLen;
*srcLen = *destLen = 0; *srcLen = *destLen = 0;
if (inSize < RC_INIT_SIZE) if (inSize < RC_INIT_SIZE)
return SZ_ERROR_INPUT_EOF; return SZ_ERROR_INPUT_EOF;

55
deps/7zip/LzmaDec.h vendored

@ -10,25 +10,14 @@
extern "C" { extern "C" {
#endif #endif
/* #define _LZMA_PROB32 */ /* ---------- LZMA Properties ---------- */
/* _LZMA_PROB32 can increase the speed on some CPUs,
but memory usage for CLzmaDec::probs will be doubled in that case */
#ifdef _LZMA_PROB32
#define CLzmaProb UInt32
#else
#define CLzmaProb UInt16
#endif
/* ---------- LZMA Properties ---------- */
#define LZMA_PROPS_SIZE 5 #define LZMA_PROPS_SIZE 5
typedef struct _CLzmaProps typedef struct _CLzmaProps
{ {
unsigned lc, lp, pb; unsigned lc, lp, pb;
UInt32 dicSize; uint32_t dicSize;
} CLzmaProps; } CLzmaProps;
/* LzmaProps_Decode - decodes properties /* LzmaProps_Decode - decodes properties
@ -37,7 +26,7 @@ SZ_OK
SZ_ERROR_UNSUPPORTED - Unsupported properties SZ_ERROR_UNSUPPORTED - Unsupported properties
*/ */
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size); SRes LzmaProps_Decode(CLzmaProps *p, const uint8_t *data, unsigned size);
/* ---------- LZMA Decoder state ---------- */ /* ---------- LZMA Decoder state ---------- */
@ -50,22 +39,22 @@ SZ_ERROR_UNSUPPORTED - Unsupported properties
typedef struct typedef struct
{ {
CLzmaProps prop; CLzmaProps prop;
CLzmaProb *probs; uint16_t *probs;
Byte *dic; uint8_t *dic;
const Byte *buf; const uint8_t *buf;
UInt32 range, code; uint32_t range, code;
SizeT dicPos; size_t dicPos;
SizeT dicBufSize; size_t dicBufSize;
UInt32 processedPos; uint32_t processedPos;
UInt32 checkDicSize; uint32_t checkDicSize;
unsigned state; unsigned state;
UInt32 reps[4]; uint32_t reps[4];
unsigned remainLen; unsigned remainLen;
int needFlush; int needFlush;
int needInitState; int needInitState;
UInt32 numProbs; uint32_t numProbs;
unsigned tempBufSize; unsigned tempBufSize;
Byte tempBuf[LZMA_REQUIRED_INPUT_MAX]; uint8_t tempBuf[LZMA_REQUIRED_INPUT_MAX];
} CLzmaDec; } CLzmaDec;
#define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; } #define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; }
@ -131,10 +120,10 @@ SZ_ERROR_UNSUPPORTED - Unsupported properties
SZ_ERROR_UNSUPPORTED - Unsupported properties SZ_ERROR_UNSUPPORTED - Unsupported properties
*/ */
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc); SRes LzmaDec_AllocateProbs(CLzmaDec *p, const uint8_t *props, unsigned propsSize, ISzAlloc *alloc);
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc); void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);
SRes LzmaDec_Allocate(CLzmaDec *state, const Byte *prop, unsigned propsSize, ISzAlloc *alloc); SRes LzmaDec_Allocate(CLzmaDec *state, const uint8_t *prop, unsigned propsSize, ISzAlloc *alloc);
void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc); void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);
/* ---------- Dictionary Interface ---------- */ /* ---------- Dictionary Interface ---------- */
@ -178,8 +167,8 @@ LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
SZ_ERROR_DATA - Data error SZ_ERROR_DATA - Data error
*/ */
SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, SRes LzmaDec_DecodeToDic(CLzmaDec *p, size_t dicLimit,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); const uint8_t *src, size_t *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
/* ---------- Buffer Interface ---------- */ /* ---------- Buffer Interface ---------- */
@ -195,8 +184,8 @@ LZMA_FINISH_ANY - Decode just destLen bytes.
LZMA_FINISH_END - Stream must be finished after (*destLen). LZMA_FINISH_END - Stream must be finished after (*destLen).
*/ */
SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, SRes LzmaDec_DecodeToBuf(CLzmaDec *p, uint8_t *dest, size_t *destLen,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); const uint8_t *src, size_t *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
/* ---------- One Call Interface ---------- */ /* ---------- One Call Interface ---------- */
@ -220,8 +209,8 @@ SZ_ERROR_UNSUPPORTED - Unsupported properties
SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src). SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
*/ */
SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, SRes LzmaDecode(uint8_t *dest, size_t *destLen, const uint8_t *src, size_t *srcLen,
const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode, const uint8_t *propData, unsigned propSize, ELzmaFinishMode finishMode,
ELzmaStatus *status, ISzAlloc *alloc); ELzmaStatus *status, ISzAlloc *alloc);
#ifdef __cplusplus #ifdef __cplusplus

46
deps/7zip/Types.h vendored

@ -52,46 +52,18 @@ typedef int WRes;
#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; } #define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }
#endif #endif
typedef unsigned char Byte;
typedef short Int16;
typedef unsigned short UInt16;
#ifdef _LZMA_UINT32_IS_ULONG
typedef long Int32;
typedef unsigned long UInt32;
#else
typedef int Int32;
typedef unsigned int UInt32;
#endif
#ifdef _SZ_NO_INT_64 #ifdef _SZ_NO_INT_64
/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers.
NOTES: Some code will work incorrectly in that case! */
typedef long Int64;
typedef unsigned long UInt64;
#else #else
#if defined(_MSC_VER) || defined(__BORLANDC__) #if defined(_MSC_VER) || defined(__BORLANDC__)
typedef __int64 Int64;
typedef unsigned __int64 UInt64;
#define UINT64_CONST(n) n #define UINT64_CONST(n) n
#else #else
typedef long long int Int64;
typedef unsigned long long int UInt64;
#define UINT64_CONST(n) n ## ULL #define UINT64_CONST(n) n ## ULL
#endif #endif
#endif #endif
#ifdef _LZMA_NO_SYSTEM_SIZE_T
typedef UInt32 SizeT;
#else
typedef size_t SizeT;
#endif
typedef int Bool; typedef int Bool;
#define True 1 #define True 1
#define False 0 #define False 0
@ -126,12 +98,12 @@ typedef int Bool;
typedef struct typedef struct
{ {
Byte (*Read)(void *p); /* reads one byte, returns 0 in case of EOF or error */ uint8_t (*Read)(void *p); /* reads one byte, returns 0 in case of EOF or error */
} IByteIn; } IByteIn;
typedef struct typedef struct
{ {
void (*Write)(void *p, Byte b); void (*Write)(void *p, uint8_t b);
} IByteOut; } IByteOut;
typedef struct typedef struct
@ -144,7 +116,7 @@ typedef struct
/* it can return SZ_ERROR_INPUT_EOF */ /* it can return SZ_ERROR_INPUT_EOF */
SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size); SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size);
SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType); SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType);
SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf); SRes SeqInStream_ReadByte(ISeqInStream *stream, uint8_t *buf);
typedef struct typedef struct
{ {
@ -163,7 +135,7 @@ typedef enum
typedef struct typedef struct
{ {
SRes (*Read)(void *p, void *buf, size_t *size); /* same as ISeqInStream::Read */ SRes (*Read)(void *p, void *buf, size_t *size); /* same as ISeqInStream::Read */
SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin); SRes (*Seek)(void *p, int64_t *pos, ESzSeek origin);
} ISeekInStream; } ISeekInStream;
typedef struct typedef struct
@ -177,11 +149,11 @@ typedef struct
SRes (*Read)(void *p, void *buf, size_t *size); SRes (*Read)(void *p, void *buf, size_t *size);
/* reads directly (without buffer). It's same as ISeqInStream::Read */ /* reads directly (without buffer). It's same as ISeqInStream::Read */
SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin); SRes (*Seek)(void *p, int64_t *pos, ESzSeek origin);
} ILookInStream; } ILookInStream;
SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size); SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size);
SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset); SRes LookInStream_SeekTo(ILookInStream *stream, uint64_t offset);
/* reads via ILookInStream::Read */ /* reads via ILookInStream::Read */
SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType); SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType);
@ -195,7 +167,7 @@ typedef struct
ISeekInStream *realStream; ISeekInStream *realStream;
size_t pos; size_t pos;
size_t size; size_t size;
Byte buf[LookToRead_BUF_SIZE]; uint8_t buf[LookToRead_BUF_SIZE];
} CLookToRead; } CLookToRead;
void LookToRead_CreateVTable(CLookToRead *p, int lookahead); void LookToRead_CreateVTable(CLookToRead *p, int lookahead);
@ -219,9 +191,9 @@ void SecToRead_CreateVTable(CSecToRead *p);
typedef struct typedef struct
{ {
SRes (*Progress)(void *p, UInt64 inSize, UInt64 outSize); SRes (*Progress)(void *p, uint64_t inSize, uint64_t outSize);
/* Returns: result. (result != SZ_OK) means break. /* Returns: result. (result != SZ_OK) means break.
Value (UInt64)(Int64)-1 for size means unknown value. */ Value (uint64_t)(int64_t)-1 for size means unknown value. */
} ICompressProgress; } ICompressProgress;
typedef struct typedef struct