libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2025-02-18 16:38:45 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #12754 from libretro/remove-7zip-typedef

Browse Source 
(7zip) Use normal stdint.h types that don't conflict with PowerPC Mac's OSTypes.h
This commit is contained in:
Autechre 2021-08-07 02:17:35 +02:00 committed by GitHub
commit b0e7a4db6a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 759 additions and 775 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
deps/7zip/7z.h vendored
View File

@ -24,15 +24,15 @@ typedef struct
typedef struct
{
size_t PropsOffset;
UInt32 MethodID;
uint32_t MethodID;
Byte NumStreams;
Byte PropsSize;
} CSzCoderInfo;
typedef struct
{
UInt32 InIndex;
UInt32 OutIndex;
uint32_t InIndex;
uint32_t OutIndex;
} CSzBond;
#define SZ_NUM_CODERS_IN_FOLDER_MAX 4
@ -41,11 +41,11 @@ typedef struct
typedef struct
{
UInt32 NumCoders;
UInt32 NumBonds;
UInt32 NumPackStreams;
UInt32 UnpackStream;
UInt32 PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];
uint32_t NumCoders;
uint32_t NumBonds;
uint32_t NumPackStreams;
uint32_t UnpackStream;
uint32_t PackStreams[SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX];
CSzBond Bonds[SZ_NUM_BONDS_IN_FOLDER_MAX];
CSzCoderInfo Coders[SZ_NUM_CODERS_IN_FOLDER_MAX];
} CSzFolder;
@ -55,20 +55,20 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd);
typedef struct
{
UInt32 Low;
UInt32 High;
uint32_t Low;
uint32_t High;
} CNtfsFileTime;
typedef struct
{
Byte *Defs; /* MSB 0 bit numbering */
UInt32 *Vals;
uint32_t *Vals;
} CSzBitUi32s;
typedef struct
{
Byte *Defs; /* MSB 0 bit numbering */
/* UInt64 *Vals; */
/* uint64_t *Vals; */
CNtfsFileTime *Vals;
} CSzBitUi64s;
@ -78,25 +78,25 @@ typedef struct
typedef struct
{
UInt32 NumPackStreams;
UInt32 NumFolders;
uint32_t NumPackStreams;
uint32_t NumFolders;
UInt64 *PackPositions; /* NumPackStreams + 1 */
uint64_t *PackPositions; /* NumPackStreams + 1 */
CSzBitUi32s FolderCRCs; /* NumFolders */
size_t *FoCodersOffsets; /* NumFolders + 1 */
UInt32 *FoStartPackStreamIndex; /* NumFolders + 1 */
UInt32 *FoToCoderUnpackSizes; /* NumFolders + 1 */
uint32_t *FoStartPackStreamIndex; /* NumFolders + 1 */
uint32_t *FoToCoderUnpackSizes; /* NumFolders + 1 */
Byte *FoToMainUnpackSizeIndex; /* NumFolders */
UInt64 *CoderUnpackSizes; /* for all coders in all folders */
uint64_t *CoderUnpackSizes; /* for all coders in all folders */
Byte *CodersData;
} CSzAr;
UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex);
uint64_t SzAr_GetFolderUnpackSize(const CSzAr *p, uint32_t folderIndex);
SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
ILookInStream *stream, UInt64 startPos,
SRes SzAr_DecodeFolder(const CSzAr *p, uint32_t folderIndex,
ILookInStream *stream, uint64_t startPos,
Byte *outBuffer, size_t outSize,
ISzAllocPtr allocMain);
@ -104,12 +104,12 @@ typedef struct
{
CSzAr db;
UInt64 startPosAfterHeader;
UInt64 dataPos;
uint64_t startPosAfterHeader;
uint64_t dataPos;
UInt32 NumFiles;
uint32_t NumFiles;
UInt64 *UnpackPositions; /* NumFiles + 1 */
uint64_t *UnpackPositions; /* NumFiles + 1 */
/* Byte *IsEmptyFiles; */
Byte *IsDirs;
CSzBitUi32s CRCs;
@ -119,8 +119,8 @@ typedef struct
CSzBitUi64s MTime;
CSzBitUi64s CTime;
UInt32 *FolderToFile; /* NumFolders + 1 */
UInt32 *FileToFolder; /* NumFiles */
uint32_t *FolderToFile; /* NumFolders + 1 */
uint32_t *FileToFolder; /* NumFiles */
size_t *FileNameOffsets; /* in 2-byte steps */
Byte *FileNames; /* UTF-16-LE */
@ -132,8 +132,8 @@ typedef struct
void SzArEx_Init(CSzArEx *p);
void SzArEx_Free(CSzArEx *p, ISzAllocPtr alloc);
UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
uint64_t SzArEx_GetFolderStreamPos(const CSzArEx *p, uint32_t folderIndex, uint32_t indexInFolder);
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,
@ -141,11 +141,11 @@ 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
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);
/*
size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);
UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest);
uint16_t *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, uint16_t *dest);
*/
@ -173,8 +173,8 @@ UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16
SRes SzArEx_Extract(
const CSzArEx *db,
ILookInStream *inStream,
UInt32 fileIndex, /* index of file */
UInt32 *blockIndex, /* index of solid block */
uint32_t fileIndex, /* index of file */
uint32_t *blockIndex, /* index of solid block */
Byte **outBuffer, /* pointer to pointer to output buffer (allocated with allocMain) */
size_t *outBufferSize, /* buffer size for output buffer */
size_t *offset, /* offset of stream for required file in *outBuffer */

280
deps/7zip/7zArcIn.c vendored
View File

@ -70,7 +70,7 @@ static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAllocPtr alloc)
else
{
MY_ALLOC(Byte, p->Defs, (num + 7) >> 3, alloc);
MY_ALLOC(UInt32, p->Vals, num, alloc);
MY_ALLOC(uint32_t, p->Vals, num, alloc);
}
return SZ_OK;
}
@ -190,11 +190,11 @@ static int TestSignatureCandidate(const Byte *testBytes)
#define SZ_READ_32(dest) if (sd.Size < 4) return SZ_ERROR_ARCHIVE; \
dest = GetUi32(sd.Data); SKIP_DATA2(sd, 4);
static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
static MY_NO_INLINE SRes ReadNumber(CSzData *sd, uint64_t *value)
{
Byte firstByte, mask;
unsigned i;
UInt32 v;
uint32_t v;
SZ_READ_BYTE(firstByte);
if ((firstByte & 0x80) == 0)
@ -205,33 +205,33 @@ static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
SZ_READ_BYTE(v);
if ((firstByte & 0x40) == 0)
{
*value = (((UInt32)firstByte & 0x3F) << 8) | v;
*value = (((uint32_t)firstByte & 0x3F) << 8) | v;
return SZ_OK;
}
SZ_READ_BYTE(mask);
*value = v | ((UInt32)mask << 8);
*value = v | ((uint32_t)mask << 8);
mask = 0x20;
for (i = 2; i < 8; i++)
{
Byte b;
if ((firstByte & mask) == 0)
{
UInt64 highPart = (unsigned)firstByte & (unsigned)(mask - 1);
uint64_t highPart = (unsigned)firstByte & (unsigned)(mask - 1);
*value |= (highPart << (8 * i));
return SZ_OK;
}
SZ_READ_BYTE(b);
*value |= ((UInt64)b << (8 * i));
*value |= ((uint64_t)b << (8 * i));
mask >>= 1;
}
return SZ_OK;
}
static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, uint32_t *value)
{
Byte firstByte;
UInt64 value64;
uint64_t value64;
if (sd->Size == 0)
return SZ_ERROR_ARCHIVE;
firstByte = *sd->Data;
@ -243,11 +243,11 @@ static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
return SZ_OK;
}
RINOK(ReadNumber(sd, &value64));
if (value64 >= (UInt32)0x80000000 - 1)
if (value64 >= (uint32_t)0x80000000 - 1)
return SZ_ERROR_UNSUPPORTED;
if (value64 >= ((UInt64)(1) << ((sizeof(size_t) - 1) * 8 + 4)))
if (value64 >= ((uint64_t)(1) << ((sizeof(size_t) - 1) * 8 + 4)))
return SZ_ERROR_UNSUPPORTED;
*value = (UInt32)value64;
*value = (uint32_t)value64;
return SZ_OK;
}
@ -255,7 +255,7 @@ static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
static SRes SkipData(CSzData *sd)
{
UInt64 size;
uint64_t size;
RINOK(ReadNumber(sd, &size));
if (size > sd->Size)
return SZ_ERROR_ARCHIVE;
@ -263,11 +263,11 @@ static SRes SkipData(CSzData *sd)
return SZ_OK;
}
static SRes WaitId(CSzData *sd, UInt32 id)
static SRes WaitId(CSzData *sd, uint32_t id)
{
for (;;)
{
UInt64 type;
uint64_t type;
RINOK(ReadID(sd, &type));
if (type == id)
return SZ_OK;
@ -277,9 +277,9 @@ static SRes WaitId(CSzData *sd, UInt32 id)
}
}
static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)
static SRes RememberBitVector(CSzData *sd, uint32_t numItems, const Byte **v)
{
UInt32 numBytes = (numItems + 7) >> 3;
uint32_t numBytes = (numItems + 7) >> 3;
if (numBytes > sd->Size)
return SZ_ERROR_ARCHIVE;
*v = sd->Data;
@ -287,11 +287,11 @@ static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)
return SZ_OK;
}
static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
static uint32_t CountDefinedBits(const Byte *bits, uint32_t numItems)
{
Byte b = 0;
unsigned m = 0;
UInt32 sum = 0;
uint32_t sum = 0;
for (; numItems != 0; numItems--)
{
if (m == 0)
@ -305,11 +305,11 @@ static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
return sum;
}
static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAllocPtr alloc)
static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, uint32_t numItems, Byte **v, ISzAllocPtr alloc)
{
Byte allAreDefined;
Byte *v2;
UInt32 numBytes = (numItems + 7) >> 3;
uint32_t numBytes = (numItems + 7) >> 3;
*v = NULL;
SZ_READ_BYTE(allAreDefined);
if (numBytes == 0)
@ -328,18 +328,18 @@ static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, I
{
unsigned numBits = (unsigned)numItems & 7;
if (numBits != 0)
v2[(size_t)numBytes - 1] = (Byte)((((UInt32)1 << numBits) - 1) << (8 - numBits));
v2[(size_t)numBytes - 1] = (Byte)((((uint32_t)1 << numBits) - 1) << (8 - numBits));
}
return SZ_OK;
}
static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, uint32_t numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
{
UInt32 i;
uint32_t i;
CSzData sd;
UInt32 *vals;
uint32_t *vals;
const Byte *defs;
MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc);
MY_ALLOC_ZE(uint32_t, crcs->Vals, numItems, alloc);
sd = *sd2;
defs = crcs->Defs;
vals = crcs->Vals;
@ -354,17 +354,17 @@ static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *c
return SZ_OK;
}
static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
static SRes ReadBitUi32s(CSzData *sd, uint32_t numItems, CSzBitUi32s *crcs, ISzAllocPtr alloc)
{
SzBitUi32s_Free(crcs, alloc);
RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc));
return ReadUi32s(sd, numItems, crcs, alloc);
}
static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
static SRes SkipBitUi32s(CSzData *sd, uint32_t numItems)
{
Byte allAreDefined;
UInt32 numDefined = numItems;
uint32_t numDefined = numItems;
SZ_READ_BYTE(allAreDefined);
if (!allAreDefined)
{
@ -385,14 +385,14 @@ static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAllocPtr alloc)
RINOK(SzReadNumber32(sd, &p->NumPackStreams));
RINOK(WaitId(sd, k7zIdSize));
MY_ALLOC(UInt64, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc);
MY_ALLOC(uint64_t, p->PackPositions, (size_t)p->NumPackStreams + 1, alloc);
{
UInt64 sum = 0;
UInt32 i;
UInt32 numPackStreams = p->NumPackStreams;
uint64_t sum = 0;
uint32_t i;
uint32_t numPackStreams = p->NumPackStreams;
for (i = 0; i < numPackStreams; i++)
{
UInt64 packSize;
uint64_t packSize;
p->PackPositions[i] = sum;
RINOK(ReadNumber(sd, &packSize));
sum += packSize;
@ -404,7 +404,7 @@ static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAllocPtr alloc)
for (;;)
{
UInt64 type;
uint64_t type;
RINOK(ReadID(sd, &type));
if (type == k7zIdEnd)
return SZ_OK;
@ -431,8 +431,8 @@ static SRes SzReadSwitch(CSzData *sd)
SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
{
UInt32 numCoders, i;
UInt32 numInStreams = 0;
uint32_t numCoders, i;
uint32_t numInStreams = 0;
const Byte *dataStart = sd->Data;
f->NumCoders = 0;
@ -449,7 +449,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
Byte mainByte;
CSzCoderInfo *coder = f->Coders + i;
unsigned idSize, j;
UInt64 id;
uint64_t id;
SZ_READ_BYTE(mainByte);
if ((mainByte & 0xC0) != 0)
@ -467,9 +467,9 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
sd->Data++;
sd->Size--;
}
if (id > (UInt32)0xFFFFFFFF)
if (id > (uint32_t)0xFFFFFFFF)
return SZ_ERROR_UNSUPPORTED;
coder->MethodID = (UInt32)id;
coder->MethodID = (uint32_t)id;
coder->NumStreams = 1;
coder->PropsOffset = 0;
@ -477,7 +477,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
if ((mainByte & 0x10) != 0)
{
UInt32 numStreams;
uint32_t numStreams;
RINOK(SzReadNumber32(sd, &numStreams));
if (numStreams > k_NumCodersStreams_in_Folder_MAX)
@ -496,7 +496,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
if ((mainByte & 0x20) != 0)
{
UInt32 propsSize = 0;
uint32_t propsSize = 0;
RINOK(SzReadNumber32(sd, &propsSize));
if (propsSize > sd->Size)
return SZ_ERROR_ARCHIVE;
@ -519,7 +519,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
*/
{
Byte streamUsed[k_NumCodersStreams_in_Folder_MAX];
UInt32 numBonds, numPackStreams;
uint32_t numBonds, numPackStreams;
numBonds = numCoders - 1;
if (numInStreams < numBonds)
@ -581,7 +581,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
else
for (i = 0; i < numPackStreams; i++)
{
UInt32 index;
uint32_t index;
RINOK(SzReadNumber32(sd, &index));
if (index >= numInStreams || streamUsed[index])
return SZ_ERROR_ARCHIVE;
@ -596,7 +596,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
}
static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, uint32_t num)
{
CSzData sd;
sd = *sd2;
@ -633,13 +633,13 @@ static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
static SRes ReadUnpackInfo(CSzAr *p,
CSzData *sd2,
UInt32 numFoldersMax,
const CBuf *tempBufs, UInt32 numTempBufs,
uint32_t numFoldersMax,
const CBuf *tempBufs, uint32_t numTempBufs,
ISzAllocPtr alloc)
{
CSzData sd;
UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;
uint32_t fo, numFolders, numCodersOutStreams, packStreamIndex;
const Byte *startBufPtr;
Byte external;
@ -655,7 +655,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
sd = *sd2;
else
{
UInt32 index;
uint32_t index;
RINOK(SzReadNumber32(sd2, &index));
if (index >= numTempBufs)
return SZ_ERROR_ARCHIVE;
@ -664,8 +664,8 @@ static SRes ReadUnpackInfo(CSzAr *p,
}
MY_ALLOC(size_t, p->FoCodersOffsets, (size_t)numFolders + 1, alloc);
MY_ALLOC(UInt32, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc);
MY_ALLOC(UInt32, p->FoToCoderUnpackSizes, (size_t)numFolders + 1, alloc);
MY_ALLOC(uint32_t, p->FoStartPackStreamIndex, (size_t)numFolders + 1, alloc);
MY_ALLOC(uint32_t, p->FoToCoderUnpackSizes, (size_t)numFolders + 1, alloc);
MY_ALLOC_ZE(Byte, p->FoToMainUnpackSizeIndex, (size_t)numFolders, alloc);
startBufPtr = sd.Data;
@ -675,7 +675,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
for (fo = 0; fo < numFolders; fo++)
{
UInt32 numCoders, ci, numInStreams = 0;
uint32_t numCoders, ci, numInStreams = 0;
p->FoCodersOffsets[fo] = sd.Data - startBufPtr;
@ -687,7 +687,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
{
Byte mainByte;
unsigned idSize;
UInt32 coderInStreams;
uint32_t coderInStreams;
SZ_READ_BYTE_2(mainByte);
if ((mainByte & 0xC0) != 0)
@ -703,7 +703,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
if ((mainByte & 0x10) != 0)
{
UInt32 coderOutStreams;
uint32_t coderOutStreams;
RINOK(SzReadNumber32(&sd, &coderInStreams));
RINOK(SzReadNumber32(&sd, &coderOutStreams));
if (coderInStreams > k_Scan_NumCodersStreams_in_Folder_MAX || coderOutStreams != 1)
@ -714,7 +714,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
if ((mainByte & 0x20) != 0)
{
UInt32 propsSize;
uint32_t propsSize;
RINOK(SzReadNumber32(&sd, &propsSize));
if (propsSize > sd.Size)
return SZ_ERROR_ARCHIVE;
@ -723,16 +723,16 @@ static SRes ReadUnpackInfo(CSzAr *p,
}
{
UInt32 indexOfMainStream = 0;
UInt32 numPackStreams = 1;
uint32_t indexOfMainStream = 0;
uint32_t numPackStreams = 1;
if (numCoders != 1 || numInStreams != 1)
{
Byte streamUsed[k_Scan_NumCodersStreams_in_Folder_MAX];
Byte coderUsed[k_Scan_NumCoders_MAX];
UInt32 i;
UInt32 numBonds = numCoders - 1;
uint32_t i;
uint32_t numBonds = numCoders - 1;
if (numInStreams < numBonds)
return SZ_ERROR_ARCHIVE;
@ -746,7 +746,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
for (i = 0; i < numBonds; i++)
{
UInt32 index;
uint32_t index;
RINOK(SzReadNumber32(&sd, &index));
if (index >= numInStreams || streamUsed[index])
@ -764,7 +764,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
if (numPackStreams != 1)
for (i = 0; i < numPackStreams; i++)
{
UInt32 index;
uint32_t index;
RINOK(SzReadNumber32(&sd, &index));
if (index >= numInStreams || streamUsed[index])
return SZ_ERROR_ARCHIVE;
@ -812,9 +812,9 @@ static SRes ReadUnpackInfo(CSzAr *p,
RINOK(WaitId(&sd, k7zIdCodersUnpackSize));
MY_ALLOC_ZE(UInt64, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc);
MY_ALLOC_ZE(uint64_t, p->CoderUnpackSizes, (size_t)numCodersOutStreams, alloc);
{
UInt32 i;
uint32_t i;
for (i = 0; i < numCodersOutStreams; i++)
{
RINOK(ReadNumber(&sd, p->CoderUnpackSizes + i));
@ -823,7 +823,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
for (;;)
{
UInt64 type;
uint64_t type;
RINOK(ReadID(&sd, &type));
if (type == k7zIdEnd)
{
@ -840,7 +840,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
}
UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)
uint64_t SzAr_GetFolderUnpackSize(const CSzAr *p, uint32_t folderIndex)
{
return p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex] + p->FoToMainUnpackSizeIndex[folderIndex]];
}
@ -848,8 +848,8 @@ UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)
typedef struct
{
UInt32 NumTotalSubStreams;
UInt32 NumSubDigests;
uint32_t NumTotalSubStreams;
uint32_t NumSubDigests;
CSzData sdNumSubStreams;
CSzData sdSizes;
CSzData sdCRCs;
@ -858,24 +858,24 @@ typedef struct
static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
{
UInt64 type = 0;
UInt32 numSubDigests = 0;
UInt32 numFolders = p->NumFolders;
UInt32 numUnpackStreams = numFolders;
UInt32 numUnpackSizesInData = 0;
uint64_t type = 0;
uint32_t numSubDigests = 0;
uint32_t numFolders = p->NumFolders;
uint32_t numUnpackStreams = numFolders;
uint32_t numUnpackSizesInData = 0;
for (;;)
{
RINOK(ReadID(sd, &type));
if (type == k7zIdNumUnpackStream)
{
UInt32 i;
uint32_t i;
ssi->sdNumSubStreams.Data = sd->Data;
numUnpackStreams = 0;
numSubDigests = 0;
for (i = 0; i < numFolders; i++)
{
UInt32 numStreams;
uint32_t numStreams;
RINOK(SzReadNumber32(sd, &numStreams));
if (numUnpackStreams > numUnpackStreams + numStreams)
return SZ_ERROR_UNSUPPORTED;
@ -931,12 +931,12 @@ static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
static SRes SzReadStreamsInfo(CSzAr *p,
CSzData *sd,
UInt32 numFoldersMax, const CBuf *tempBufs, UInt32 numTempBufs,
UInt64 *dataOffset,
uint32_t numFoldersMax, const CBuf *tempBufs, uint32_t numTempBufs,
uint64_t *dataOffset,
CSubStreamInfo *ssi,
ISzAllocPtr alloc)
{
UInt64 type;
uint64_t type;
SzData_Clear(&ssi->sdSizes);
SzData_Clear(&ssi->sdCRCs);
@ -973,13 +973,13 @@ static SRes SzReadAndDecodePackedStreams(
ILookInStream *inStream,
CSzData *sd,
CBuf *tempBufs,
UInt32 numFoldersMax,
UInt64 baseOffset,
uint32_t numFoldersMax,
uint64_t baseOffset,
CSzAr *p,
ISzAllocPtr allocTemp)
{
UInt64 dataStartPos;
UInt32 fo;
uint64_t dataStartPos;
uint32_t fo;
CSubStreamInfo ssi;
RINOK(SzReadStreamsInfo(p, sd, numFoldersMax, NULL, 0, &dataStartPos, &ssi, allocTemp));
@ -994,7 +994,7 @@ static SRes SzReadAndDecodePackedStreams(
for (fo = 0; fo < p->NumFolders; fo++)
{
CBuf *tempBuf = tempBufs + fo;
UInt64 unpackSize = SzAr_GetFolderUnpackSize(p, fo);
uint64_t unpackSize = SzAr_GetFolderUnpackSize(p, fo);
if ((size_t)unpackSize != unpackSize)
return SZ_ERROR_MEM;
if (!Buf_Create(tempBuf, (size_t)unpackSize, allocTemp))
@ -1011,7 +1011,7 @@ static SRes SzReadAndDecodePackedStreams(
return SZ_OK;
}
static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size_t *offsets)
static SRes SzReadFileNames(const Byte *data, size_t size, uint32_t numFiles, size_t *offsets)
{
size_t pos = 0;
*offsets++ = 0;
@ -1028,7 +1028,7 @@ static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size
return SZ_ERROR_ARCHIVE;
for (p = data + pos;
#ifdef _WIN32
*(const UInt16 *)p != 0
*(const uint16_t *)p != 0
#else
p[0] != 0 || p[1] != 0
#endif
@ -1040,13 +1040,13 @@ static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size
return (pos == size) ? SZ_OK : SZ_ERROR_ARCHIVE;
}
static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,
static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, uint32_t num,
CSzData *sd2,
const CBuf *tempBufs, UInt32 numTempBufs,
const CBuf *tempBufs, uint32_t numTempBufs,
ISzAllocPtr alloc)
{
CSzData sd;
UInt32 i;
uint32_t i;
CNtfsFileTime *vals;
Byte *defs;
Byte external;
@ -1058,7 +1058,7 @@ static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,
sd = *sd2;
else
{
UInt32 index;
uint32_t index;
RINOK(SzReadNumber32(sd2, &index));
if (index >= numTempBufs)
return SZ_ERROR_ARCHIVE;
@ -1095,7 +1095,7 @@ static SRes SzReadHeader2(
CSzArEx *p, /* allocMain */
CSzData *sd,
ILookInStream *inStream,
CBuf *tempBufs, UInt32 *numTempBufs,
CBuf *tempBufs, uint32_t *numTempBufs,
ISzAllocPtr allocMain,
ISzAllocPtr allocTemp
)
@ -1103,7 +1103,7 @@ static SRes SzReadHeader2(
CSubStreamInfo ssi;
{
UInt64 type;
uint64_t type;
SzData_Clear(&ssi.sdSizes);
SzData_Clear(&ssi.sdCRCs);
@ -1118,7 +1118,7 @@ static SRes SzReadHeader2(
{
for (;;)
{
UInt64 type2;
uint64_t type2;
RINOK(ReadID(sd, &type2));
if (type2 == k7zIdEnd)
break;
@ -1145,7 +1145,7 @@ static SRes SzReadHeader2(
if (type == k7zIdMainStreamsInfo)
{
RINOK(SzReadStreamsInfo(&p->db, sd, (UInt32)1 << 30, tempBufs, *numTempBufs,
RINOK(SzReadStreamsInfo(&p->db, sd, (uint32_t)1 << 30, tempBufs, *numTempBufs,
&p->dataPos, &ssi, allocMain));
p->dataPos += p->startPosAfterHeader;
RINOK(ReadID(sd, &type));
@ -1161,8 +1161,8 @@ static SRes SzReadHeader2(
}
{
UInt32 numFiles = 0;
UInt32 numEmptyStreams = 0;
uint32_t numFiles = 0;
uint32_t numEmptyStreams = 0;
const Byte *emptyStreams = NULL;
const Byte *emptyFiles = NULL;
@ -1171,8 +1171,8 @@ static SRes SzReadHeader2(
for (;;)
{
UInt64 type;
UInt64 size;
uint64_t type;
uint64_t size;
RINOK(ReadID(sd, &type));
if (type == k7zIdEnd)
break;
@ -1180,7 +1180,7 @@ static SRes SzReadHeader2(
if (size > sd->Size)
return SZ_ERROR_ARCHIVE;
if (type >= ((UInt32)1 << 8))
if (type >= ((uint32_t)1 << 8))
{
SKIP_DATA(sd, size);
}
@ -1200,7 +1200,7 @@ static SRes SzReadHeader2(
}
else
{
UInt32 index;
uint32_t index;
RINOK(SzReadNumber32(sd, &index));
if (index >= *numTempBufs)
return SZ_ERROR_ARCHIVE;
@ -1244,7 +1244,7 @@ static SRes SzReadHeader2(
sdPtr = sd;
else
{
UInt32 index;
uint32_t index;
RINOK(SzReadNumber32(sd, &index));
if (index >= *numTempBufs)
return SZ_ERROR_ARCHIVE;
@ -1279,7 +1279,7 @@ static SRes SzReadHeader2(
for (;;)
{
UInt64 type;
uint64_t type;
RINOK(ReadID(sd, &type));
if (type == k7zIdEnd)
break;
@ -1287,24 +1287,24 @@ static SRes SzReadHeader2(
}
{
UInt32 i;
UInt32 emptyFileIndex = 0;
UInt32 folderIndex = 0;
UInt32 remSubStreams = 0;
UInt32 numSubStreams = 0;
UInt64 unpackPos = 0;
uint32_t i;
uint32_t emptyFileIndex = 0;
uint32_t folderIndex = 0;
uint32_t remSubStreams = 0;
uint32_t numSubStreams = 0;
uint64_t unpackPos = 0;
const Byte *digestsDefs = NULL;
const Byte *digestsVals = NULL;
UInt32 digestsValsIndex = 0;
UInt32 digestIndex;
uint32_t digestsValsIndex = 0;
uint32_t digestIndex;
Byte allDigestsDefined = 0;
Byte isDirMask = 0;
Byte crcMask = 0;
Byte mask = 0x80;
MY_ALLOC(UInt32, p->FolderToFile, p->db.NumFolders + 1, allocMain);
MY_ALLOC_ZE(UInt32, p->FileToFolder, p->NumFiles, allocMain);
MY_ALLOC(UInt64, p->UnpackPositions, p->NumFiles + 1, allocMain);
MY_ALLOC(uint32_t, p->FolderToFile, p->db.NumFolders + 1, allocMain);
MY_ALLOC_ZE(uint32_t, p->FileToFolder, p->NumFiles, allocMain);
MY_ALLOC(uint64_t, p->UnpackPositions, p->NumFiles + 1, allocMain);
MY_ALLOC_ZE(Byte, p->IsDirs, (p->NumFiles + 7) >> 3, allocMain);
RINOK(SzBitUi32s_Alloc(&p->CRCs, p->NumFiles, allocMain));
@ -1328,7 +1328,7 @@ static SRes SzReadHeader2(
{
if (mask == 0)
{
UInt32 byteIndex = (i - 1) >> 3;
uint32_t byteIndex = (i - 1) >> 3;
p->IsDirs[byteIndex] = isDirMask;
p->CRCs.Defs[byteIndex] = crcMask;
isDirMask = 0;
@ -1351,7 +1351,7 @@ static SRes SzReadHeader2(
isDirMask |= mask;
if (remSubStreams == 0)
{
p->FileToFolder[i] = (UInt32)-1;
p->FileToFolder[i] = (uint32_t)-1;
continue;
}
}
@ -1372,7 +1372,7 @@ static SRes SzReadHeader2(
if (numSubStreams != 0)
break;
{
UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
uint64_t folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
unpackPos += folderUnpackSize;
if (unpackPos < folderUnpackSize)
return SZ_ERROR_ARCHIVE;
@ -1389,8 +1389,8 @@ static SRes SzReadHeader2(
if (--remSubStreams == 0)
{
UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
UInt64 startFolderUnpackPos = p->UnpackPositions[p->FolderToFile[folderIndex]];
uint64_t folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
uint64_t startFolderUnpackPos = p->UnpackPositions[p->FolderToFile[folderIndex]];
if (folderUnpackSize < unpackPos - startFolderUnpackPos)
return SZ_ERROR_ARCHIVE;
unpackPos = startFolderUnpackPos + folderUnpackSize;
@ -1413,7 +1413,7 @@ static SRes SzReadHeader2(
}
else
{
UInt64 v;
uint64_t v;
RINOK(ReadNumber(&ssi.sdSizes, &v));
unpackPos += v;
if (unpackPos < v)
@ -1429,7 +1429,7 @@ static SRes SzReadHeader2(
if (mask != 0x80)
{
UInt32 byteIndex = (i - 1) >> 3;
uint32_t byteIndex = (i - 1) >> 3;
p->IsDirs[byteIndex] = isDirMask;
p->CRCs.Defs[byteIndex] = crcMask;
}
@ -1451,7 +1451,7 @@ static SRes SzReadHeader2(
return SZ_ERROR_ARCHIVE;
/*
{
UInt64 folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
uint64_t folderUnpackSize = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
unpackPos += folderUnpackSize;
if (unpackPos < folderUnpackSize)
return SZ_ERROR_ARCHIVE;
@ -1475,8 +1475,8 @@ static SRes SzReadHeader(
ISzAllocPtr allocMain,
ISzAllocPtr allocTemp)
{
UInt32 i;
UInt32 numTempBufs = 0;
uint32_t i;
uint32_t numTempBufs = 0;
SRes res;
CBuf tempBufs[NUM_ADDITIONAL_STREAMS_MAX];
@ -1506,9 +1506,9 @@ static SRes SzArEx_Open2(
{
Byte header[k7zStartHeaderSize];
Int64 startArcPos;
UInt64 nextHeaderOffset, nextHeaderSize;
uint64_t nextHeaderOffset, nextHeaderSize;
size_t nextHeaderSizeT;
UInt32 nextHeaderCRC;
uint32_t nextHeaderCRC;
CBuf buf;
SRes res;
@ -1543,9 +1543,9 @@ static SRes SzArEx_Open2(
{
Int64 pos = 0;
RINOK(ILookInStream_Seek(inStream, &pos, SZ_SEEK_END));
if ((UInt64)pos < startArcPos + nextHeaderOffset ||
(UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
(UInt64)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
if ((uint64_t)pos < startArcPos + nextHeaderOffset ||
(uint64_t)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset ||
(uint64_t)pos < startArcPos + k7zStartHeaderSize + nextHeaderOffset + nextHeaderSize)
return SZ_ERROR_INPUT_EOF;
}
@ -1562,7 +1562,7 @@ static SRes SzArEx_Open2(
if (CrcCalc(buf.data, nextHeaderSizeT) == nextHeaderCRC)
{
CSzData sd;
UInt64 type;
uint64_t type;
sd.Data = buf.data;
sd.Size = buf.size;
@ -1635,8 +1635,8 @@ SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
SRes SzArEx_Extract(
const CSzArEx *p,
ILookInStream *inStream,
UInt32 fileIndex,
UInt32 *blockIndex,
uint32_t fileIndex,
uint32_t *blockIndex,
Byte **tempBuf,
size_t *outBufferSize,
size_t *offset,
@ -1644,13 +1644,13 @@ SRes SzArEx_Extract(
ISzAllocPtr allocMain,
ISzAllocPtr allocTemp)
{
UInt32 folderIndex = p->FileToFolder[fileIndex];
uint32_t folderIndex = p->FileToFolder[fileIndex];
SRes res = SZ_OK;
*offset = 0;
*outSizeProcessed = 0;
if (folderIndex == (UInt32)-1)
if (folderIndex == (uint32_t)-1)
{
ISzAlloc_Free(allocMain, *tempBuf);
*blockIndex = folderIndex;
@ -1661,9 +1661,9 @@ SRes SzArEx_Extract(
if (*tempBuf == NULL || *blockIndex != folderIndex)
{
UInt64 unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
uint64_t unpackSizeSpec = SzAr_GetFolderUnpackSize(&p->db, folderIndex);
/*
UInt64 unpackSizeSpec =
uint64_t unpackSizeSpec =
p->UnpackPositions[p->FolderToFile[(size_t)folderIndex + 1]] -
p->UnpackPositions[p->FolderToFile[folderIndex]];
*/
@ -1695,7 +1695,7 @@ SRes SzArEx_Extract(
if (res == SZ_OK)
{
UInt64 unpackPos = p->UnpackPositions[fileIndex];
uint64_t unpackPos = p->UnpackPositions[fileIndex];
*offset = (size_t)(unpackPos - p->UnpackPositions[p->FolderToFile[folderIndex]]);
*outSizeProcessed = (size_t)(p->UnpackPositions[(size_t)fileIndex + 1] - unpackPos);
if (*offset + *outSizeProcessed > *outBufferSize)
@ -1709,7 +1709,7 @@ SRes SzArEx_Extract(
}
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)
{
size_t offs = p->FileNameOffsets[fileIndex];
size_t len = p->FileNameOffsets[fileIndex + 1] - offs;
@ -1732,17 +1732,17 @@ size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex)
len = 0;
for (;;)
{
UInt32 parent = (UInt32)(Int32)-1;
uint32_t parent = (uint32_t)(Int32)-1;
len += p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
if SzBitWithVals_Check(&p->Parents, fileIndex)
parent = p->Parents.Vals[fileIndex];
if (parent == (UInt32)(Int32)-1)
if (parent == (uint32_t)(Int32)-1)
return len;
fileIndex = parent;
}
}
UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
uint16_t *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, uint16_t *dest)
{
BoolInt needSlash;
if (!p->FileNameOffsets)
@ -1753,7 +1753,7 @@ UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16
needSlash = False;
for (;;)
{
UInt32 parent = (UInt32)(Int32)-1;
uint32_t parent = (uint32_t)(Int32)-1;
size_t curLen = p->FileNameOffsets[fileIndex + 1] - p->FileNameOffsets[fileIndex];
SzArEx_GetFileNameUtf16(p, fileIndex, dest - curLen);
if (needSlash)
@ -1763,7 +1763,7 @@ UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16
if SzBitWithVals_Check(&p->Parents, fileIndex)
parent = p->Parents.Vals[fileIndex];
if (parent == (UInt32)(Int32)-1)
if (parent == (uint32_t)(Int32)-1)
return dest;
fileIndex = parent;
}

30
deps/7zip/7zCrc.c vendored
View File

@ -15,36 +15,36 @@
#define CRC_UINT32_SWAP(v) ((v >> 24) | ((v >> 8) & 0xFF00) | ((v << 8) & 0xFF0000) | (v << 24))
UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
uint32_t MY_FAST_CALL CrcUpdateT1_BeT4(uint32_t v, const void *data, size_t size, const uint32_t *table);
uint32_t MY_FAST_CALL CrcUpdateT1_BeT8(uint32_t v, const void *data, size_t size, const uint32_t *table);
#endif
#ifndef MY_CPU_BE
UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const UInt32 *table);
UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const UInt32 *table);
uint32_t MY_FAST_CALL CrcUpdateT4(uint32_t v, const void *data, size_t size, const uint32_t *table);
uint32_t MY_FAST_CALL CrcUpdateT8(uint32_t v, const void *data, size_t size, const uint32_t *table);
#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);
CRC_FUNC g_CrcUpdateT4;
CRC_FUNC g_CrcUpdateT8;
CRC_FUNC g_CrcUpdate;
UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
uint32_t g_CrcTable[256 * CRC_NUM_TABLES];
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);
}
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;
}
#define CRC_UPDATE_BYTE_2(crc, b) (table[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table)
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 Byte *pEnd = p + size;
@ -55,18 +55,18 @@ UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const U
void MY_FAST_CALL CrcGenerateTable()
{
UInt32 i;
uint32_t i;
for (i = 0; i < 256; i++)
{
UInt32 r = i;
uint32_t r = i;
unsigned j;
for (j = 0; j < 8; j++)
r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));
r = (r >> 1) ^ (kCrcPoly & ((uint32_t)0 - (r & 1)));
g_CrcTable[i] = r;
}
for (i = 256; i < 256 * CRC_NUM_TABLES; i++)
{
UInt32 r = g_CrcTable[(size_t)i - 256];
uint32_t r = g_CrcTable[(size_t)i - 256];
g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
}
@ -93,7 +93,7 @@ void MY_FAST_CALL CrcGenerateTable()
#else
{
#ifndef MY_CPU_BE
UInt32 k = 0x01020304;
uint32_t k = 0x01020304;
const Byte *p = (const Byte *)&k;
if (p[0] == 4 && p[1] == 3)
{
@ -111,7 +111,7 @@ void MY_FAST_CALL CrcGenerateTable()
{
for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
{
UInt32 x = g_CrcTable[(size_t)i - 256];
uint32_t x = g_CrcTable[(size_t)i - 256];
g_CrcTable[i] = CRC_UINT32_SWAP(x);
}
g_CrcUpdateT4 = CrcUpdateT1_BeT4;

6
deps/7zip/7zCrc.h vendored
View File

@ -8,7 +8,7 @@
EXTERN_C_BEGIN
extern UInt32 g_CrcTable[];
extern uint32_t g_CrcTable[];
/* Call CrcGenerateTable one time before other CRC functions */
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_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 MY_FAST_CALL CrcCalc(const void *data, size_t size);
uint32_t MY_FAST_CALL CrcUpdate(uint32_t crc, const void *data, size_t size);
uint32_t MY_FAST_CALL CrcCalc(const void *data, size_t size);
EXTERN_C_END

24
deps/7zip/7zCrcOpt.c vendored
View File

@ -9,14 +9,14 @@
#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)
{
const Byte *p = (const Byte *)data;
for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
v = CRC_UPDATE_BYTE_2(v, *p);
for (; size >= 4; size -= 4, p += 4)
{
v ^= *(const UInt32 *)p;
v ^= *(const uint32_t *)p;
v =
(table + 0x300)[((v ) & 0xFF)]
^ (table + 0x200)[((v >> 8) & 0xFF)]
@ -28,21 +28,21 @@ UInt32 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void *data, size_t size, const U
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)
{
const Byte *p = (const Byte *)data;
for (; size > 0 && ((unsigned)(ptrdiff_t)p & 7) != 0; size--, p++)
v = CRC_UPDATE_BYTE_2(v, *p);
for (; size >= 8; size -= 8, p += 8)
{
UInt32 d;
v ^= *(const UInt32 *)p;
uint32_t d;
v ^= *(const uint32_t *)p;
v =
(table + 0x700)[((v ) & 0xFF)]
^ (table + 0x600)[((v >> 8) & 0xFF)]
^ (table + 0x500)[((v >> 16) & 0xFF)]
^ (table + 0x400)[((v >> 24))];
d = *((const UInt32 *)p + 1);
d = *((const uint32_t *)p + 1);
v ^=
(table + 0x300)[((d ) & 0xFF)]
^ (table + 0x200)[((d >> 8) & 0xFF)]
@ -63,7 +63,7 @@ UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void *data, size_t size, const U
#define CRC_UPDATE_BYTE_2_BE(crc, b) (table[(((crc) >> 24) ^ (b))] ^ ((crc) << 8))
UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, const UInt32 *table)
uint32_t MY_FAST_CALL CrcUpdateT1_BeT4(uint32_t v, const void *data, size_t size, const uint32_t *table)
{
const Byte *p = (const Byte *)data;
table += 0x100;
@ -72,7 +72,7 @@ UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, co
v = CRC_UPDATE_BYTE_2_BE(v, *p);
for (; size >= 4; size -= 4, p += 4)
{
v ^= *(const UInt32 *)p;
v ^= *(const uint32_t *)p;
v =
(table + 0x000)[((v ) & 0xFF)]
^ (table + 0x100)[((v >> 8) & 0xFF)]
@ -84,7 +84,7 @@ UInt32 MY_FAST_CALL CrcUpdateT1_BeT4(UInt32 v, const void *data, size_t size, co
return CRC_UINT32_SWAP(v);
}
UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, const UInt32 *table)
uint32_t MY_FAST_CALL CrcUpdateT1_BeT8(uint32_t v, const void *data, size_t size, const uint32_t *table)
{
const Byte *p = (const Byte *)data;
table += 0x100;
@ -93,14 +93,14 @@ UInt32 MY_FAST_CALL CrcUpdateT1_BeT8(UInt32 v, const void *data, size_t size, co
v = CRC_UPDATE_BYTE_2_BE(v, *p);
for (; size >= 8; size -= 8, p += 8)
{
UInt32 d;
v ^= *(const UInt32 *)p;
uint32_t d;
v ^= *(const uint32_t *)p;
v =
(table + 0x400)[((v ) & 0xFF)]
^ (table + 0x500)[((v >> 8) & 0xFF)]
^ (table + 0x600)[((v >> 16) & 0xFF)]
^ (table + 0x700)[((v >> 24))];
d = *((const UInt32 *)p + 1);
d = *((const uint32_t *)p + 1);
v ^=
(table + 0x000)[((d ) & 0xFF)]
^ (table + 0x100)[((d >> 8) & 0xFF)]

52
deps/7zip/7zDec.c vendored
View File

@ -43,7 +43,7 @@ typedef struct
const Byte *cur;
const Byte *end;
const Byte *begin;
UInt64 processed;
uint64_t processed;
BoolInt extra;
SRes res;
const ILookInStream *inStream;
@ -70,7 +70,7 @@ static Byte ReadByte(const IByteIn *pp)
return 0;
}
static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, const ILookInStream *inStream,
static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, uint64_t inSize, const ILookInStream *inStream,
Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
{
CPpmd7 ppmd;
@ -89,7 +89,7 @@ static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, c
{
unsigned order = props[0];
UInt32 memSize = GetUi32(props + 1);
uint32_t memSize = GetUi32(props + 1);
if (order < PPMD7_MIN_ORDER ||
order > PPMD7_MAX_ORDER ||
memSize < PPMD7_MIN_MEM_SIZE ||
@ -131,7 +131,7 @@ static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, c
#endif
static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, uint64_t inSize, ILookInStream *inStream,
Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
{
CLzmaDec state;
@ -191,7 +191,7 @@ static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, I
#ifndef _7Z_NO_METHOD_LZMA2
static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, uint64_t inSize, ILookInStream *inStream,
Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain)
{
CLzma2Dec state;
@ -250,7 +250,7 @@ static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize,
#endif
static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer)
static SRes SzDecodeCopy(uint64_t inSize, ILookInStream *inStream, Byte *outBuffer)
{
while (inSize > 0)
{
@ -269,7 +269,7 @@ static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer
return SZ_OK;
}
static BoolInt IS_MAIN_METHOD(UInt32 m)
static BoolInt IS_MAIN_METHOD(uint32_t m)
{
switch (m)
{
@ -290,8 +290,8 @@ static BoolInt IS_SUPPORTED_CODER(const CSzCoderInfo *c)
{
return
c->NumStreams == 1
/* && c->MethodID <= (UInt32)0xFFFFFFFF */
&& IS_MAIN_METHOD((UInt32)c->MethodID);
/* && c->MethodID <= (uint32_t)0xFFFFFFFF */
&& IS_MAIN_METHOD((uint32_t)c->MethodID);
}
#define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumStreams == 4)
@ -316,7 +316,7 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
{
const CSzCoderInfo *c = &f->Coders[1];
if (
/* c->MethodID > (UInt32)0xFFFFFFFF || */
/* c->MethodID > (uint32_t)0xFFFFFFFF || */
c->NumStreams != 1
|| f->NumPackStreams != 1
|| f->PackStreams[0] != 0
@ -324,7 +324,7 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
|| f->Bonds[0].InIndex != 1
|| f->Bonds[0].OutIndex != 0)
return SZ_ERROR_UNSUPPORTED;
switch ((UInt32)c->MethodID)
switch ((uint32_t)c->MethodID)
{
case k_Delta:
case k_BCJ:
@ -369,13 +369,13 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
static SRes SzFolder_Decode2(const CSzFolder *folder,
const Byte *propsData,
const UInt64 *unpackSizes,
const UInt64 *packPositions,
ILookInStream *inStream, UInt64 startPos,
const uint64_t *unpackSizes,
const uint64_t *packPositions,
ILookInStream *inStream, uint64_t startPos,
Byte *outBuffer, SizeT outSize, ISzAllocPtr allocMain,
Byte *tempBuf[])
{
UInt32 ci;
uint32_t ci;
SizeT tempSizes[3] = { 0, 0, 0};
SizeT tempSize3 = 0;
Byte *tempBuf3 = 0;
@ -386,17 +386,17 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
{
const CSzCoderInfo *coder = &folder->Coders[ci];
if (IS_MAIN_METHOD((UInt32)coder->MethodID))
if (IS_MAIN_METHOD((uint32_t)coder->MethodID))
{
UInt32 si = 0;
UInt64 offset;
UInt64 inSize;
uint32_t si = 0;
uint64_t offset;
uint64_t inSize;
Byte *outBufCur = outBuffer;
SizeT outSizeCur = outSize;
if (folder->NumCoders == 4)
{
UInt32 indices[] = { 3, 2, 0 };
UInt64 unpackSize = unpackSizes[ci];
uint32_t indices[] = { 3, 2, 0 };
uint64_t unpackSize = unpackSizes[ci];
si = indices[ci];
if (ci < 2)
{
@ -451,8 +451,8 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
}
else if (coder->MethodID == k_BCJ2)
{
UInt64 offset = packPositions[1];
UInt64 s3Size = packPositions[2] - offset;
uint64_t offset = packPositions[1];
uint64_t s3Size = packPositions[2] - offset;
if (ci != 3)
return SZ_ERROR_UNSUPPORTED;
@ -522,7 +522,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
{
case k_BCJ:
{
UInt32 state;
uint32_t state;
x86_Convert_Init(state);
x86_Convert(outBuffer, outSize, 0, &state, 0);
break;
@ -546,8 +546,8 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
}
SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
ILookInStream *inStream, UInt64 startPos,
SRes SzAr_DecodeFolder(const CSzAr *p, uint32_t folderIndex,
ILookInStream *inStream, uint64_t startPos,
Byte *outBuffer, size_t outSize,
ISzAllocPtr allocMain)
{

6
deps/7zip/7zFile.c vendored
View File

@ -173,7 +173,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
LARGE_INTEGER value;
DWORD moveMethod;
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)
{
case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;
@ -209,7 +209,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
#endif
}
WRes File_GetLength(CSzFile *p, UInt64 *length)
WRes File_GetLength(CSzFile *p, uint64_t *length)
{
#ifdef USE_WINDOWS_FILE
@ -221,7 +221,7 @@ WRes File_GetLength(CSzFile *p, UInt64 *length)
if (res != NO_ERROR)
return res;
}
*length = (((UInt64)sizeHigh) << 32) + sizeLow;
*length = (((uint64_t)sizeHigh) << 32) + sizeLow;
return 0;
#else

4
deps/7zip/7zFile.h vendored
View File

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

6
deps/7zip/7zStream.c vendored
View File

@ -35,9 +35,9 @@ SRes SeqInStream_ReadByte(const ISeqInStream *stream, Byte *buf)
SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset)
SRes LookInStream_SeekTo(const ILookInStream *stream, uint64_t offset)
{
Int64 t = offset;
int64_t t = offset;
return ILookInStream_Seek(stream, &t, SZ_SEEK_SET);
}
@ -134,7 +134,7 @@ static SRes LookToRead2_Read(const ILookInStream *pp, void *buf, size_t *size)
return SZ_OK;
}
static SRes LookToRead2_Seek(const ILookInStream *pp, Int64 *pos, ESzSeek origin)
static SRes LookToRead2_Seek(const ILookInStream *pp, int64_t *pos, ESzSeek origin)
{
GET_LookToRead2
p->pos = p->size = 0;

26
deps/7zip/7zTypes.h vendored
View File

@ -4,11 +4,8 @@
#ifndef __7Z_TYPES_H
#define __7Z_TYPES_H
#ifdef _WIN32
/* #include <windows.h> */
#endif
#include <stddef.h>
#include <stdint.h>
#ifndef EXTERN_C_BEGIN
#ifdef __cplusplus
@ -67,15 +64,6 @@ typedef int WRes;
typedef unsigned char Byte;
#endif
typedef short Int16;
typedef unsigned short UInt16;
#if defined(_LZMA_UINT32_IS_ULONG) && !defined(__LP64__)
typedef long Int32;
typedef unsigned long UInt32;
#else
typedef int Int32;
typedef unsigned int UInt32;
#endif
#ifdef _SZ_NO_INT_64
@ -83,24 +71,20 @@ typedef unsigned int UInt32;
NOTES: Some code will work incorrectly in that case! */
typedef long Int64;
typedef unsigned long UInt64;
#else
#if defined(_MSC_VER) || defined(__BORLANDC__)
typedef __int64 Int64;
typedef unsigned __int64 UInt64;
#define UINT64_CONST(n) n
#else
typedef long long int Int64;
typedef unsigned long long int UInt64;
#define UINT64_CONST(n) n ## ULL
#endif
#endif
#ifdef _LZMA_NO_SYSTEM_SIZE_T
typedef UInt32 SizeT;
typedef uint32_t SizeT;
#else
typedef size_t SizeT;
#endif
@ -232,7 +216,7 @@ struct ILookInStream
SRes LookInStream_LookRead(const ILookInStream *stream, void *buf, size_t *size);
SRes LookInStream_SeekTo(const ILookInStream *stream, UInt64 offset);
SRes LookInStream_SeekTo(const ILookInStream *stream, uint64_t offset);
/* reads via ILookInStream::Read */
SRes LookInStream_Read2(const ILookInStream *stream, void *buf, size_t size, SRes errorType);
@ -281,9 +265,9 @@ typedef struct ICompressProgress ICompressProgress;
struct ICompressProgress
{
SRes (*Progress)(const ICompressProgress *p, UInt64 inSize, UInt64 outSize);
SRes (*Progress)(const ICompressProgress *p, uint64_t inSize, uint64_t outSize);
/* Returns: result. (result != SZ_OK) means break.
Value (UInt64)(Int64)-1 for size means unknown value. */
Value (uint64_t)(Int64)-1 for size means unknown value. */
};
#define ICompressProgress_Progress(p, inSize, outSize) (p)->Progress(p, inSize, outSize)

14
deps/7zip/Bcj2.c vendored
View File

@ -6,10 +6,10 @@
#include "Bcj2.h"
#include "CpuArch.h"
#define CProb UInt16
#define CProb uint16_t
#undef kTopValue
#define kTopValue ((UInt32)1 << 24)
#define kTopValue ((uint32_t)1 << 24)
#define kNumModelBits 11
#undef kBitModelTotal
#define kBitModelTotal (1 << kNumModelBits)
@ -78,7 +78,7 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
p->bufs[p->state] = cur + 4;
{
UInt32 val;
uint32_t val;
Byte *dest;
SizeT rem;
@ -176,7 +176,7 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
{
p->temp[3] = src[-1];
p->bufs[BCJ2_STREAM_MAIN] = src;
p->ip += (UInt32)num;
p->ip += (uint32_t)num;
p->dest += num;
p->state =
p->bufs[BCJ2_STREAM_MAIN] ==
@ -187,7 +187,7 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
}
{
UInt32 bound, ttt;
uint32_t bound, ttt;
CProb *prob;
Byte b = src[0];
Byte prev = (Byte)(num == 0 ? p->temp[3] : src[-1]);
@ -195,7 +195,7 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
p->temp[3] = b;
p->bufs[BCJ2_STREAM_MAIN] = src + 1;
num++;
p->ip += (UInt32)num;
p->ip += (uint32_t)num;
p->dest += num;
prob = p->probs + (unsigned)(b == 0xE8 ? 2 + (unsigned)prev : (b == 0xE9 ? 1 : 0));
@ -212,7 +212,7 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
}
{
UInt32 val;
uint32_t val;
unsigned cj = (p->temp[3] == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
const Byte *cur = p->bufs[cj];
Byte *dest;

30
deps/7zip/Bcj2.h vendored
View File

@ -68,11 +68,11 @@ typedef struct
unsigned state; /* BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */
UInt32 ip;
uint32_t ip;
Byte temp[4];
UInt32 range;
UInt32 code;
UInt16 probs[2 + 256];
uint32_t range;
uint32_t code;
uint16_t probs[2 + 256];
} CBcj2Dec;
void Bcj2Dec_Init(CBcj2Dec *p);
@ -104,28 +104,28 @@ typedef struct
Byte prevByte;
Byte cache;
UInt32 range;
UInt64 low;
UInt64 cacheSize;
uint32_t range;
uint64_t low;
uint64_t cacheSize;
UInt32 ip;
uint32_t ip;
/* 32-bit ralative offset in JUMP/CALL commands is
- (mod 4 GB) in 32-bit mode
- signed Int32 in 64-bit mode
We use (mod 4 GB) check for fileSize.
Use fileSize up to 2 GB, if you want to support 32-bit and 64-bit code conversion. */
UInt32 fileIp;
UInt32 fileSize; /* (fileSize <= ((UInt32)1 << 31)), 0 means no_limit */
UInt32 relatLimit; /* (relatLimit <= ((UInt32)1 << 31)), 0 means desable_conversion */
uint32_t fileIp;
uint32_t fileSize; /* (fileSize <= ((uint32_t)1 << 31)), 0 means no_limit */
uint32_t relatLimit; /* (relatLimit <= ((uint32_t)1 << 31)), 0 means desable_conversion */
UInt32 tempTarget;
uint32_t tempTarget;
unsigned tempPos;
Byte temp[4 * 2];
unsigned flushPos;
UInt16 probs[2 + 256];
uint16_t probs[2 + 256];
} CBcj2Enc;
void Bcj2Enc_Init(CBcj2Enc *p);
@ -136,10 +136,10 @@ void Bcj2Enc_Encode(CBcj2Enc *p);
#define BCJ2_RELAT_LIMIT_NUM_BITS 26
#define BCJ2_RELAT_LIMIT ((UInt32)1 << BCJ2_RELAT_LIMIT_NUM_BITS)
#define BCJ2_RELAT_LIMIT ((uint32_t)1 << BCJ2_RELAT_LIMIT_NUM_BITS)
/* limit for CBcj2Enc::fileSize variable */
#define BCJ2_FileSize_MAX ((UInt32)1 << 31)
#define BCJ2_FileSize_MAX ((uint32_t)1 << 31)
EXTERN_C_END

70
deps/7zip/Bra.c vendored
View File

@ -6,7 +6,7 @@
#include "CpuArch.h"
#include "Bra.h"
SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT ARM_Convert(Byte *data, SizeT size, uint32_t ip, int encoding)
{
Byte *p;
const Byte *lim;
@ -28,9 +28,9 @@ SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
break;
}
{
UInt32 v = GetUi32(p - 4);
uint32_t v = GetUi32(p - 4);
v <<= 2;
v += ip + (UInt32)(p - data);
v += ip + (uint32_t)(p - data);
v >>= 2;
v &= 0x00FFFFFF;
v |= 0xEB000000;
@ -49,9 +49,9 @@ SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
break;
}
{
UInt32 v = GetUi32(p - 4);
uint32_t v = GetUi32(p - 4);
v <<= 2;
v -= ip + (UInt32)(p - data);
v -= ip + (uint32_t)(p - data);
v >>= 2;
v &= 0x00FFFFFF;
v |= 0xEB000000;
@ -61,7 +61,7 @@ SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
}
SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT ARMT_Convert(Byte *data, SizeT size, uint32_t ip, int encoding)
{
Byte *p;
const Byte *lim;
@ -73,10 +73,10 @@ SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
for (;;)
{
UInt32 b1;
uint32_t b1;
for (;;)
{
UInt32 b3;
uint32_t b3;
if (p > lim)
return p - data;
b1 = p[1];
@ -87,15 +87,15 @@ SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
break;
}
{
UInt32 v =
((UInt32)b1 << 19)
+ (((UInt32)p[1] & 0x7) << 8)
+ (((UInt32)p[-2] << 11))
uint32_t v =
((uint32_t)b1 << 19)
+ (((uint32_t)p[1] & 0x7) << 8)
+ (((uint32_t)p[-2] << 11))
+ (p[0]);
p += 2;
{
UInt32 cur = (ip + (UInt32)(p - data)) >> 1;
uint32_t cur = (ip + (uint32_t)(p - data)) >> 1;
v += cur;
}
@ -108,10 +108,10 @@ SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
for (;;)
{
UInt32 b1;
uint32_t b1;
for (;;)
{
UInt32 b3;
uint32_t b3;
if (p > lim)
return p - data;
b1 = p[1];
@ -122,21 +122,21 @@ SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
break;
}
{
UInt32 v =
((UInt32)b1 << 19)
+ (((UInt32)p[1] & 0x7) << 8)
+ (((UInt32)p[-2] << 11))
uint32_t v =
((uint32_t)b1 << 19)
+ (((uint32_t)p[1] & 0x7) << 8)
+ (((uint32_t)p[-2] << 11))
+ (p[0]);
p += 2;
{
UInt32 cur = (ip + (UInt32)(p - data)) >> 1;
uint32_t cur = (ip + (uint32_t)(p - data)) >> 1;
v -= cur;
}
/*
SetUi16(p - 4, (UInt16)(((v >> 11) & 0x7FF) | 0xF000));
SetUi16(p - 2, (UInt16)(v | 0xF800));
SetUi16(p - 4, (uint16_t)(((v >> 11) & 0x7FF) | 0xF000));
SetUi16(p - 2, (uint16_t)(v | 0xF800));
*/
p[-4] = (Byte)(v >> 11);
@ -148,7 +148,7 @@ SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
}
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT PPC_Convert(Byte *data, SizeT size, uint32_t ip, int encoding)
{
Byte *p;
const Byte *lim;
@ -169,11 +169,11 @@ SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
break;
}
{
UInt32 v = GetBe32(p - 4);
uint32_t v = GetBe32(p - 4);
if (encoding)
v += ip + (UInt32)(p - data);
v += ip + (uint32_t)(p - data);
else
v -= ip + (UInt32)(p - data);
v -= ip + (uint32_t)(p - data);
v &= 0x03FFFFFF;
v |= 0x48000000;
SetBe32(p - 4, v);
@ -182,7 +182,7 @@ SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
}
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT SPARC_Convert(Byte *data, SizeT size, uint32_t ip, int encoding)
{
Byte *p;
const Byte *lim;
@ -200,10 +200,10 @@ SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
/*
v = GetBe32(p);
p += 4;
m = v + ((UInt32)5 << 29);
m ^= (UInt32)7 << 29;
m += (UInt32)1 << 22;
if ((m & ((UInt32)0x1FF << 23)) == 0)
m = v + ((uint32_t)5 << 29);
m ^= (uint32_t)7 << 29;
m += (uint32_t)1 << 22;
if ((m & ((uint32_t)0x1FF << 23)) == 0)
break;
*/
p += 4;
@ -212,15 +212,15 @@ SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
break;
}
{
UInt32 v = GetBe32(p - 4);
uint32_t v = GetBe32(p - 4);
v <<= 2;
if (encoding)
v += ip + (UInt32)(p - data);
v += ip + (uint32_t)(p - data);
else
v -= ip + (UInt32)(p - data);
v -= ip + (uint32_t)(p - data);
v &= 0x01FFFFFF;
v -= (UInt32)1 << 24;
v -= (uint32_t)1 << 24;
v ^= 0xFF000000;
v >>= 2;
v |= 0x40000000;

14
deps/7zip/Bra.h vendored
View File

@ -40,7 +40,7 @@ in CALL instructions to increase the compression ratio.
Example:
UInt32 ip = 0;
uint32_t ip = 0;
for ()
{
; size must be >= Alignment + LookAhead, if it's not last block
@ -52,12 +52,12 @@ in CALL instructions to increase the compression ratio.
*/
#define x86_Convert_Init(state) { state = 0; }
SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding);
SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding);
SizeT x86_Convert(Byte *data, SizeT size, uint32_t ip, uint32_t *state, int encoding);
SizeT ARM_Convert(Byte *data, SizeT size, uint32_t ip, int encoding);
SizeT ARMT_Convert(Byte *data, SizeT size, uint32_t ip, int encoding);
SizeT PPC_Convert(Byte *data, SizeT size, uint32_t ip, int encoding);
SizeT SPARC_Convert(Byte *data, SizeT size, uint32_t ip, int encoding);
SizeT IA64_Convert(Byte *data, SizeT size, uint32_t ip, int encoding);
EXTERN_C_END

10
deps/7zip/Bra86.c vendored
View File

@ -7,10 +7,10 @@
#define Test86MSByte(b) ((((b) + 1) & 0xFE) == 0)
SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding)
SizeT x86_Convert(Byte *data, SizeT size, uint32_t ip, uint32_t *state, int encoding)
{
SizeT pos = 0;
UInt32 mask = *state & 7;
uint32_t mask = *state & 7;
if (size < 5)
return 0;
size -= 4;
@ -48,8 +48,8 @@ SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding
if (Test86MSByte(p[4]))
{
UInt32 v = ((UInt32)p[4] << 24) | ((UInt32)p[3] << 16) | ((UInt32)p[2] << 8) | ((UInt32)p[1]);
UInt32 cur = ip + (UInt32)pos;
uint32_t v = ((uint32_t)p[4] << 24) | ((uint32_t)p[3] << 16) | ((uint32_t)p[2] << 8) | ((uint32_t)p[1]);
uint32_t cur = ip + (uint32_t)pos;
pos += 5;
if (encoding)
v += cur;
@ -60,7 +60,7 @@ SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding
unsigned sh = (mask & 6) << 2;
if (Test86MSByte((Byte)(v >> sh)))
{
v ^= (((UInt32)0x100 << sh) - 1);
v ^= (((uint32_t)0x100 << sh) - 1);
if (encoding)
v += cur;
else

12
deps/7zip/BraIA64.c vendored
View File

@ -6,7 +6,7 @@
#include "CpuArch.h"
#include "Bra.h"
SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT IA64_Convert(Byte *data, SizeT size, uint32_t ip, int encoding)
{
SizeT i;
if (size < 16)
@ -15,7 +15,7 @@ SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
i = 0;
do
{
unsigned m = ((UInt32)0x334B0000 >> (data[i] & 0x1E)) & 3;
unsigned m = ((uint32_t)0x334B0000 >> (data[i] & 0x1E)) & 3;
if (m)
{
m++;
@ -23,7 +23,7 @@ SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
{
Byte *p = data + (i + (size_t)m * 5 - 8);
if (((p[3] >> m) & 15) == 5
&& (((p[-1] | ((UInt32)p[0] << 8)) >> m) & 0x70) == 0)
&& (((p[-1] | ((uint32_t)p[0] << 8)) >> m) & 0x70) == 0)
{
unsigned raw = GetUi32(p);
unsigned v = raw >> m;
@ -31,15 +31,15 @@ SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
v <<= 4;
if (encoding)
v += ip + (UInt32)i;
v += ip + (uint32_t)i;
else
v -= ip + (UInt32)i;
v -= ip + (uint32_t)i;
v >>= 4;
v &= 0x1FFFFF;
v += 0x700000;
v &= 0x8FFFFF;
raw &= ~((UInt32)0x8FFFFF << m);
raw &= ~((uint32_t)0x8FFFFF << m);
raw |= (v << m);
SetUi32(p, raw);
}

16
deps/7zip/CpuArch.c vendored
View File

@ -16,7 +16,7 @@
#endif
#if defined(USE_ASM) && !defined(MY_CPU_AMD64)
static UInt32 CheckFlag(UInt32 flag)
static uint32_t CheckFlag(uint32_t flag)
{
#ifdef _MSC_VER
__asm pushfd;
@ -55,13 +55,13 @@ static UInt32 CheckFlag(UInt32 flag)
#define CHECK_CPUID_IS_SUPPORTED
#endif
void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)
void MyCPUID(uint32_t function, uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d)
{
#ifdef USE_ASM
#ifdef _MSC_VER
UInt32 a2, b2, c2, d2;
uint32_t a2, b2, c2, d2;
__asm xor EBX, EBX;
__asm xor ECX, ECX;
__asm xor EDX, EDX;
@ -123,7 +123,7 @@ BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p)
return True;
}
static const UInt32 kVendors[][3] =
static const uint32_t kVendors[][3] =
{
{ 0x756E6547, 0x49656E69, 0x6C65746E},
{ 0x68747541, 0x69746E65, 0x444D4163},
@ -135,7 +135,7 @@ int x86cpuid_GetFirm(const Cx86cpuid *p)
unsigned i;
for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[i]); i++)
{
const UInt32 *v = kVendors[i];
const uint32_t *v = kVendors[i];
if (v[0] == p->vendor[0] &&
v[1] == p->vendor[1] &&
v[2] == p->vendor[2])
@ -148,7 +148,7 @@ BoolInt CPU_Is_InOrder(void)
{
Cx86cpuid p;
int firm;
UInt32 family, model;
uint32_t family, model;
if (!x86cpuid_CheckAndRead(&p))
return True;
@ -203,13 +203,13 @@ BoolInt CPU_IsSupported_PageGB(void)
if (!x86cpuid_CheckAndRead(&cpuid))
return False;
{
UInt32 d[4] = { 0 };
uint32_t d[4] = { 0 };
MyCPUID(0x80000000, &d[0], &d[1], &d[2], &d[3]);
if (d[0] < 0x80000001)
return False;
}
{
UInt32 d[4] = { 0 };
uint32_t d[4] = { 0 };
MyCPUID(0x80000001, &d[0], &d[1], &d[2], &d[3]);
return (d[3] >> 26) & 1;
}

78
deps/7zip/CpuArch.h vendored
View File

@ -198,41 +198,41 @@ MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned mem
#ifdef MY_CPU_LE_UNALIGN
#define GetUi16(p) (*(const UInt16 *)(const void *)(p))
#define GetUi32(p) (*(const UInt32 *)(const void *)(p))
#define GetUi64(p) (*(const UInt64 *)(const void *)(p))
#define GetUi16(p) (*(const uint16_t *)(const void *)(p))
#define GetUi32(p) (*(const uint32_t *)(const void *)(p))
#define GetUi64(p) (*(const uint64_t *)(const void *)(p))
#define SetUi16(p, v) { *(UInt16 *)(p) = (v); }
#define SetUi32(p, v) { *(UInt32 *)(p) = (v); }
#define SetUi64(p, v) { *(UInt64 *)(p) = (v); }
#define SetUi16(p, v) { *(uint16_t *)(p) = (v); }
#define SetUi32(p, v) { *(uint32_t *)(p) = (v); }
#define SetUi64(p, v) { *(uint64_t *)(p) = (v); }
#else
#define GetUi16(p) ( (UInt16) ( \
#define GetUi16(p) ( (uint16_t) ( \
((const Byte *)(p))[0] | \
((UInt16)((const Byte *)(p))[1] << 8) ))
((uint16_t)((const Byte *)(p))[1] << 8) ))
#define GetUi32(p) ( \
((const Byte *)(p))[0] | \
((UInt32)((const Byte *)(p))[1] << 8) | \
((UInt32)((const Byte *)(p))[2] << 16) | \
((UInt32)((const Byte *)(p))[3] << 24))
((uint32_t)((const Byte *)(p))[1] << 8) | \
((uint32_t)((const Byte *)(p))[2] << 16) | \
((uint32_t)((const Byte *)(p))[3] << 24))
#define GetUi64(p) (GetUi32(p) | ((UInt64)GetUi32(((const Byte *)(p)) + 4) << 32))
#define GetUi64(p) (GetUi32(p) | ((uint64_t)GetUi32(((const Byte *)(p)) + 4) << 32))
#define SetUi16(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
#define SetUi16(p, v) { Byte *_ppp_ = (Byte *)(p); uint32_t _vvv_ = (v); \
_ppp_[0] = (Byte)_vvv_; \
_ppp_[1] = (Byte)(_vvv_ >> 8); }
#define SetUi32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
#define SetUi32(p, v) { Byte *_ppp_ = (Byte *)(p); uint32_t _vvv_ = (v); \
_ppp_[0] = (Byte)_vvv_; \
_ppp_[1] = (Byte)(_vvv_ >> 8); \
_ppp_[2] = (Byte)(_vvv_ >> 16); \
_ppp_[3] = (Byte)(_vvv_ >> 24); }
#define SetUi64(p, v) { Byte *_ppp2_ = (Byte *)(p); UInt64 _vvv2_ = (v); \
SetUi32(_ppp2_ , (UInt32)_vvv2_); \
SetUi32(_ppp2_ + 4, (UInt32)(_vvv2_ >> 32)); }
#define SetUi64(p, v) { Byte *_ppp2_ = (Byte *)(p); uint64_t _vvv2_ = (v); \
SetUi32(_ppp2_ , (uint32_t)_vvv2_); \
SetUi32(_ppp2_ + 4, (uint32_t)(_vvv2_ >> 32)); }
#endif
@ -252,33 +252,33 @@ MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned mem
#pragma intrinsic(_byteswap_ulong)
#pragma intrinsic(_byteswap_uint64)
/* #define GetBe16(p) _byteswap_ushort(*(const UInt16 *)(const Byte *)(p)) */
#define GetBe32(p) _byteswap_ulong(*(const UInt32 *)(const Byte *)(p))
#define GetBe64(p) _byteswap_uint64(*(const UInt64 *)(const Byte *)(p))
/* #define GetBe16(p) _byteswap_ushort(*(const uint16_t *)(const Byte *)(p)) */
#define GetBe32(p) _byteswap_ulong(*(const uint32_t *)(const Byte *)(p))
#define GetBe64(p) _byteswap_uint64(*(const uint64_t *)(const Byte *)(p))
#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = _byteswap_ulong(v)
#define SetBe32(p, v) (*(uint32_t *)(void *)(p)) = _byteswap_ulong(v)
#elif defined(MY_CPU_LE_UNALIGN) && ( \
(defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))) \
|| (defined(__clang__) && MY__has_builtin(__builtin_bswap16)) )
/* #define GetBe16(p) __builtin_bswap16(*(const UInt16 *)(const Byte *)(p)) */
#define GetBe32(p) __builtin_bswap32(*(const UInt32 *)(const Byte *)(p))
#define GetBe64(p) __builtin_bswap64(*(const UInt64 *)(const Byte *)(p))
/* #define GetBe16(p) __builtin_bswap16(*(const uint16_t *)(const Byte *)(p)) */
#define GetBe32(p) __builtin_bswap32(*(const uint32_t *)(const Byte *)(p))
#define GetBe64(p) __builtin_bswap64(*(const uint64_t *)(const Byte *)(p))
#define SetBe32(p, v) (*(UInt32 *)(void *)(p)) = __builtin_bswap32(v)
#define SetBe32(p, v) (*(uint32_t *)(void *)(p)) = __builtin_bswap32(v)
#else
#define GetBe32(p) ( \
((UInt32)((const Byte *)(p))[0] << 24) | \
((UInt32)((const Byte *)(p))[1] << 16) | \
((UInt32)((const Byte *)(p))[2] << 8) | \
((uint32_t)((const Byte *)(p))[0] << 24) | \
((uint32_t)((const Byte *)(p))[1] << 16) | \
((uint32_t)((const Byte *)(p))[2] << 8) | \
((const Byte *)(p))[3] )
#define GetBe64(p) (((UInt64)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))
#define GetBe64(p) (((uint64_t)GetBe32(p) << 32) | GetBe32(((const Byte *)(p)) + 4))
#define SetBe32(p, v) { Byte *_ppp_ = (Byte *)(p); UInt32 _vvv_ = (v); \
#define SetBe32(p, v) { Byte *_ppp_ = (Byte *)(p); uint32_t _vvv_ = (v); \
_ppp_[0] = (Byte)(_vvv_ >> 24); \
_ppp_[1] = (Byte)(_vvv_ >> 16); \
_ppp_[2] = (Byte)(_vvv_ >> 8); \
@ -289,8 +289,8 @@ MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned mem
#ifndef GetBe16
#define GetBe16(p) ( (UInt16) ( \
((UInt16)((const Byte *)(p))[0] << 8) | \
#define GetBe16(p) ( (uint16_t) ( \
((uint16_t)((const Byte *)(p))[0] << 8) | \
((const Byte *)(p))[1] ))
#endif
@ -301,12 +301,12 @@ MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned mem
typedef struct
{
UInt32 maxFunc;
UInt32 vendor[3];
UInt32 ver;
UInt32 b;
UInt32 c;
UInt32 d;
uint32_t maxFunc;
uint32_t vendor[3];
uint32_t ver;
uint32_t b;
uint32_t c;
uint32_t d;
} Cx86cpuid;
enum
@ -316,7 +316,7 @@ enum
CPU_FIRM_VIA
};
void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d);
void MyCPUID(uint32_t function, uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d);
BoolInt x86cpuid_CheckAndRead(Cx86cpuid *p);
int x86cpuid_GetFirm(const Cx86cpuid *p);

186
deps/7zip/LzFind.c vendored
View File

@ -9,10 +9,10 @@
#include "LzHash.h"
#define kEmptyHashValue 0
#define kMaxValForNormalize ((UInt32)0xFFFFFFFF)
#define kMaxValForNormalize ((uint32_t)0xFFFFFFFF)
#define kNormalizeStepMin (1 << 10) /* it must be power of 2 */
#define kNormalizeMask (~(UInt32)(kNormalizeStepMin - 1))
#define kMaxHistorySize ((UInt32)7 << 29)
#define kNormalizeMask (~(uint32_t)(kNormalizeStepMin - 1))
#define kMaxHistorySize ((uint32_t)7 << 29)
#define kStartMaxLen 3
@ -27,9 +27,9 @@ static void LzInWindow_Free(CMatchFinder *p, ISzAllocPtr alloc)
/* keepSizeBefore + keepSizeAfter + keepSizeReserv must be < 4G) */
static int LzInWindow_Create(CMatchFinder *p, UInt32 keepSizeReserv, ISzAllocPtr alloc)
static int LzInWindow_Create(CMatchFinder *p, uint32_t keepSizeReserv, ISzAllocPtr alloc)
{
UInt32 blockSize = p->keepSizeBefore + p->keepSizeAfter + keepSizeReserv;
uint32_t blockSize = p->keepSizeBefore + p->keepSizeAfter + keepSizeReserv;
if (p->directInput)
{
p->blockSize = blockSize;
@ -46,9 +46,9 @@ static int LzInWindow_Create(CMatchFinder *p, UInt32 keepSizeReserv, ISzAllocPtr
Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p) { return p->buffer; }
UInt32 MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return p->streamPos - p->pos; }
uint32_t MatchFinder_GetNumAvailableBytes(CMatchFinder *p) { return p->streamPos - p->pos; }
void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue)
void MatchFinder_ReduceOffsets(CMatchFinder *p, uint32_t subValue)
{
p->posLimit -= subValue;
p->pos -= subValue;
@ -64,9 +64,9 @@ static void MatchFinder_ReadBlock(CMatchFinder *p)
if (p->directInput)
{
UInt32 curSize = 0xFFFFFFFF - (p->streamPos - p->pos);
uint32_t curSize = 0xFFFFFFFF - (p->streamPos - p->pos);
if (curSize > p->directInputRem)
curSize = (UInt32)p->directInputRem;
curSize = (uint32_t)p->directInputRem;
p->directInputRem -= curSize;
p->streamPos += curSize;
if (p->directInputRem == 0)
@ -89,7 +89,7 @@ static void MatchFinder_ReadBlock(CMatchFinder *p)
p->streamEndWasReached = 1;
return;
}
p->streamPos += (UInt32)size;
p->streamPos += (uint32_t)size;
if (p->streamPos - p->pos > p->keepSizeAfter)
return;
}
@ -142,15 +142,15 @@ void MatchFinder_Construct(CMatchFinder *p)
p->bufferBase = NULL;
p->directInput = 0;
p->hash = NULL;
p->expectedDataSize = (UInt64)(Int64)-1;
p->expectedDataSize = (uint64_t)(int64_t)-1;
MatchFinder_SetDefaultSettings(p);
for (i = 0; i < 256; i++)
{
UInt32 r = (UInt32)i;
uint32_t r = (uint32_t)i;
unsigned j;
for (j = 0; j < 8; j++)
r = (r >> 1) ^ (kCrcPoly & ((UInt32)0 - (r & 1)));
r = (r >> 1) ^ (kCrcPoly & ((uint32_t)0 - (r & 1)));
p->crc[i] = r;
}
}
@ -175,11 +175,11 @@ static CLzRef* AllocRefs(size_t num, ISzAllocPtr alloc)
return (CLzRef *)ISzAlloc_Alloc(alloc, sizeInBytes);
}
int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
int MatchFinder_Create(CMatchFinder *p, uint32_t historySize,
uint32_t keepAddBufferBefore, uint32_t matchMaxLen, uint32_t keepAddBufferAfter,
ISzAllocPtr alloc)
{
UInt32 sizeReserv;
uint32_t sizeReserv;
if (historySize > kMaxHistorySize)
{
@ -188,8 +188,8 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
}
sizeReserv = historySize >> 1;
if (historySize >= ((UInt32)3 << 30)) sizeReserv = historySize >> 3;
else if (historySize >= ((UInt32)2 << 30)) sizeReserv = historySize >> 2;
if (historySize >= ((uint32_t)3 << 30)) sizeReserv = historySize >> 3;
else if (historySize >= ((uint32_t)2 << 30)) sizeReserv = historySize >> 2;
sizeReserv += (keepAddBufferBefore + matchMaxLen + keepAddBufferAfter) / 2 + (1 << 19);
@ -200,8 +200,8 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
if (LzInWindow_Create(p, sizeReserv, alloc))
{
UInt32 newCyclicBufferSize = historySize + 1;
UInt32 hs;
uint32_t newCyclicBufferSize = historySize + 1;
uint32_t hs;
p->matchMaxLen = matchMaxLen;
{
p->fixedHashSize = 0;
@ -211,7 +211,7 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
{
hs = historySize;
if (hs > p->expectedDataSize)
hs = (UInt32)p->expectedDataSize;
hs = (uint32_t)p->expectedDataSize;
if (hs != 0)
hs--;
hs |= (hs >> 1);
@ -270,8 +270,8 @@ int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
static void MatchFinder_SetLimits(CMatchFinder *p)
{
UInt32 limit = kMaxValForNormalize - p->pos;
UInt32 limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
uint32_t limit = kMaxValForNormalize - p->pos;
uint32_t limit2 = p->cyclicBufferSize - p->cyclicBufferPos;
if (limit2 < limit)
limit = limit2;
@ -289,7 +289,7 @@ static void MatchFinder_SetLimits(CMatchFinder *p)
limit = limit2;
{
UInt32 lenLimit = p->streamPos - p->pos;
uint32_t lenLimit = p->streamPos - p->pos;
if (lenLimit > p->matchMaxLen)
lenLimit = p->matchMaxLen;
p->lenLimit = lenLimit;
@ -342,17 +342,17 @@ void MatchFinder_Init(CMatchFinder *p)
}
static UInt32 MatchFinder_GetSubValue(CMatchFinder *p)
static uint32_t MatchFinder_GetSubValue(CMatchFinder *p)
{
return (p->pos - p->historySize - 1) & kNormalizeMask;
}
void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems)
void MatchFinder_Normalize3(uint32_t subValue, CLzRef *items, size_t numItems)
{
size_t i;
for (i = 0; i < numItems; i++)
{
UInt32 value = items[i];
uint32_t value = items[i];
if (value <= subValue)
value = kEmptyHashValue;
else
@ -363,7 +363,7 @@ void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems)
static void MatchFinder_Normalize(CMatchFinder *p)
{
UInt32 subValue = MatchFinder_GetSubValue(p);
uint32_t subValue = MatchFinder_GetSubValue(p);
MatchFinder_Normalize3(subValue, p->hash, p->numRefs);
MatchFinder_ReduceOffsets(p, subValue);
}
@ -386,15 +386,15 @@ static void MatchFinder_CheckLimits(CMatchFinder *p)
(lenLimit > maxLen)
*/
MY_FORCE_INLINE
static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
UInt32 *distances, unsigned maxLen)
static uint32_t * Hc_GetMatchesSpec(unsigned lenLimit, uint32_t curMatch, uint32_t pos, const Byte *cur, CLzRef *son,
uint32_t _cyclicBufferPos, uint32_t _cyclicBufferSize, uint32_t cutValue,
uint32_t *distances, unsigned maxLen)
{
/*
son[_cyclicBufferPos] = curMatch;
for (;;)
{
UInt32 delta = pos - curMatch;
uint32_t delta = pos - curMatch;
if (cutValue-- == 0 || delta >= _cyclicBufferSize)
return distances;
{
@ -402,7 +402,7 @@ static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, UInt32 pos
curMatch = son[_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)];
if (pb[maxLen] == cur[maxLen] && *pb == *cur)
{
UInt32 len = 0;
uint32_t len = 0;
while (++len != lenLimit)
if (pb[len] != cur[len])
break;
@ -423,7 +423,7 @@ static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, UInt32 pos
son[_cyclicBufferPos] = curMatch;
do
{
UInt32 delta = pos - curMatch;
uint32_t delta = pos - curMatch;
if (delta >= _cyclicBufferSize)
break;
{
@ -437,7 +437,7 @@ static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, UInt32 pos
{
if (++c == lim)
{
distances[0] = (UInt32)(lim - cur);
distances[0] = (uint32_t)(lim - cur);
distances[1] = delta - 1;
return distances + 2;
}
@ -447,7 +447,7 @@ static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, UInt32 pos
if (maxLen < len)
{
maxLen = len;
distances[0] = (UInt32)len;
distances[0] = (uint32_t)len;
distances[1] = delta - 1;
distances += 2;
}
@ -462,16 +462,16 @@ static UInt32 * Hc_GetMatchesSpec(unsigned lenLimit, UInt32 curMatch, UInt32 pos
MY_FORCE_INLINE
UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue,
UInt32 *distances, UInt32 maxLen)
uint32_t * GetMatchesSpec1(uint32_t lenLimit, uint32_t curMatch, uint32_t pos, const Byte *cur, CLzRef *son,
uint32_t _cyclicBufferPos, uint32_t _cyclicBufferSize, uint32_t cutValue,
uint32_t *distances, uint32_t maxLen)
{
CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
unsigned len0 = 0, len1 = 0;
for (;;)
{
UInt32 delta = pos - curMatch;
uint32_t delta = pos - curMatch;
if (cutValue-- == 0 || delta >= _cyclicBufferSize)
{
*ptr0 = *ptr1 = kEmptyHashValue;
@ -481,7 +481,7 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byt
CLzRef *pair = son + ((size_t)(_cyclicBufferPos - delta + ((delta > _cyclicBufferPos) ? _cyclicBufferSize : 0)) << 1);
const Byte *pb = cur - delta;
unsigned len = (len0 < len1 ? len0 : len1);
UInt32 pair0 = pair[0];
uint32_t pair0 = pair[0];
if (pb[len] == cur[len])
{
if (++len != lenLimit && pb[len] == cur[len])
@ -490,8 +490,8 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byt
break;
if (maxLen < len)
{
maxLen = (UInt32)len;
*distances++ = (UInt32)len;
maxLen = (uint32_t)len;
*distances++ = (uint32_t)len;
*distances++ = delta - 1;
if (len == lenLimit)
{
@ -519,15 +519,15 @@ UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byt
}
}
static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *cur, CLzRef *son,
UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 cutValue)
static void SkipMatchesSpec(uint32_t lenLimit, uint32_t curMatch, uint32_t pos, const Byte *cur, CLzRef *son,
uint32_t _cyclicBufferPos, uint32_t _cyclicBufferSize, uint32_t cutValue)
{
CLzRef *ptr0 = son + ((size_t)_cyclicBufferPos << 1) + 1;
CLzRef *ptr1 = son + ((size_t)_cyclicBufferPos << 1);
unsigned len0 = 0, len1 = 0;
for (;;)
{
UInt32 delta = pos - curMatch;
uint32_t delta = pos - curMatch;
if (cutValue-- == 0 || delta >= _cyclicBufferSize)
{
*ptr0 = *ptr1 = kEmptyHashValue;
@ -574,12 +574,12 @@ static void SkipMatchesSpec(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const
p->buffer++; \
if (++p->pos == p->posLimit) MatchFinder_CheckLimits(p);
#define MOVE_POS_RET MOVE_POS return (UInt32)offset;
#define MOVE_POS_RET MOVE_POS return (uint32_t)offset;
static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; }
#define GET_MATCHES_HEADER2(minLen, ret_op) \
unsigned lenLimit; UInt32 hv; const Byte *cur; UInt32 curMatch; \
unsigned lenLimit; uint32_t hv; const Byte *cur; uint32_t curMatch; \
lenLimit = (unsigned)p->lenLimit; { if (lenLimit < minLen) { MatchFinder_MovePos(p); ret_op; }} \
cur = p->buffer;
@ -589,11 +589,11 @@ static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; }
#define MF_PARAMS(p) p->pos, p->buffer, p->son, p->cyclicBufferPos, p->cyclicBufferSize, p->cutValue
#define GET_MATCHES_FOOTER(offset, maxLen) \
offset = (unsigned)(GetMatchesSpec1((UInt32)lenLimit, curMatch, MF_PARAMS(p), \
distances + offset, (UInt32)maxLen) - distances); MOVE_POS_RET;
offset = (unsigned)(GetMatchesSpec1((uint32_t)lenLimit, curMatch, MF_PARAMS(p), \
distances + offset, (uint32_t)maxLen) - distances); MOVE_POS_RET;
#define SKIP_FOOTER \
SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p)); MOVE_POS;
SkipMatchesSpec((uint32_t)lenLimit, curMatch, MF_PARAMS(p)); MOVE_POS;
#define UPDATE_maxLen { \
ptrdiff_t diff = (ptrdiff_t)0 - d2; \
@ -602,7 +602,7 @@ static void MatchFinder_MovePos(CMatchFinder *p) { MOVE_POS; }
for (; c != lim; c++) if (*(c + diff) != *c) break; \
maxLen = (unsigned)(c - cur); }
static UInt32 Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
static uint32_t Bt2_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
unsigned offset;
GET_MATCHES_HEADER(2)
@ -613,7 +613,7 @@ static UInt32 Bt2_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
GET_MATCHES_FOOTER(offset, 1)
}
UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
uint32_t Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
unsigned offset;
GET_MATCHES_HEADER(3)
@ -624,11 +624,11 @@ UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
GET_MATCHES_FOOTER(offset, 2)
}
static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
static uint32_t Bt3_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
UInt32 h2, d2, pos;
uint32_t h2, d2, pos;
unsigned maxLen, offset;
UInt32 *hash;
uint32_t *hash;
GET_MATCHES_HEADER(3)
HASH3_CALC;
@ -649,12 +649,12 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
if (d2 < p->cyclicBufferSize && *(cur - d2) == *cur)
{
UPDATE_maxLen
distances[0] = (UInt32)maxLen;
distances[0] = (uint32_t)maxLen;
distances[1] = d2 - 1;
offset = 2;
if (maxLen == lenLimit)
{
SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p));
SkipMatchesSpec((uint32_t)lenLimit, curMatch, MF_PARAMS(p));
MOVE_POS_RET;
}
}
@ -662,11 +662,11 @@ static UInt32 Bt3_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
GET_MATCHES_FOOTER(offset, maxLen)
}
static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
static uint32_t Bt4_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
UInt32 h2, h3, d2, d3, pos;
uint32_t h2, h3, d2, d3, pos;
unsigned maxLen, offset;
UInt32 *hash;
uint32_t *hash;
GET_MATCHES_HEADER(4)
HASH4_CALC;
@ -705,10 +705,10 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
if (offset != 0)
{
UPDATE_maxLen
distances[(size_t)offset - 2] = (UInt32)maxLen;
distances[(size_t)offset - 2] = (uint32_t)maxLen;
if (maxLen == lenLimit)
{
SkipMatchesSpec((UInt32)lenLimit, curMatch, MF_PARAMS(p));
SkipMatchesSpec((uint32_t)lenLimit, curMatch, MF_PARAMS(p));
MOVE_POS_RET;
}
}
@ -720,10 +720,10 @@ static UInt32 Bt4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
}
/*
static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
static uint32_t Bt5_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
UInt32 h2, h3, h4, d2, d3, d4, maxLen, offset, pos;
UInt32 *hash;
uint32_t h2, h3, h4, d2, d3, d4, maxLen, offset, pos;
uint32_t *hash;
GET_MATCHES_HEADER(5)
HASH5_CALC;
@ -796,11 +796,11 @@ static UInt32 Bt5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
}
*/
static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
static uint32_t Hc4_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
UInt32 h2, h3, d2, d3, pos;
uint32_t h2, h3, d2, d3, pos;
unsigned maxLen, offset;
UInt32 *hash;
uint32_t *hash;
GET_MATCHES_HEADER(4)
HASH4_CALC;
@ -838,7 +838,7 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
if (offset != 0)
{
UPDATE_maxLen
distances[(size_t)offset - 2] = (UInt32)maxLen;
distances[(size_t)offset - 2] = (uint32_t)maxLen;
if (maxLen == lenLimit)
{
p->son[p->cyclicBufferPos] = curMatch;
@ -855,10 +855,10 @@ static UInt32 Hc4_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
}
/*
static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
static uint32_t Hc5_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
UInt32 h2, h3, h4, d2, d3, d4, maxLen, offset, pos
UInt32 *hash;
uint32_t h2, h3, h4, d2, d3, d4, maxLen, offset, pos
uint32_t *hash;
GET_MATCHES_HEADER(5)
HASH5_CALC;
@ -927,13 +927,13 @@ static UInt32 Hc5_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
if (maxLen < 4)
maxLen = 4;
offset = (UInt32)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
offset = (uint32_t)(Hc_GetMatchesSpec(lenLimit, curMatch, MF_PARAMS(p),
distances + offset, maxLen) - (distances));
MOVE_POS_RET
}
*/
UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
uint32_t Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances)
{
unsigned offset;
GET_MATCHES_HEADER(3)
@ -945,7 +945,7 @@ UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances)
MOVE_POS_RET
}
static void Bt2_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
static void Bt2_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{
@ -958,7 +958,7 @@ static void Bt2_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
while (--num != 0);
}
void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{
@ -971,12 +971,12 @@ void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
while (--num != 0);
}
static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
static void Bt3_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{
UInt32 h2;
UInt32 *hash;
uint32_t h2;
uint32_t *hash;
SKIP_HEADER(3)
HASH3_CALC;
hash = p->hash;
@ -988,12 +988,12 @@ static void Bt3_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
while (--num != 0);
}
static void Bt4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
static void Bt4_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{
UInt32 h2, h3;
UInt32 *hash;
uint32_t h2, h3;
uint32_t *hash;
SKIP_HEADER(4)
HASH4_CALC;
hash = p->hash;
@ -1007,12 +1007,12 @@ static void Bt4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
}
/*
static void Bt5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
static void Bt5_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{
UInt32 h2, h3, h4;
UInt32 *hash;
uint32_t h2, h3, h4;
uint32_t *hash;
SKIP_HEADER(5)
HASH5_CALC;
hash = p->hash;
@ -1027,12 +1027,12 @@ static void Bt5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
}
*/
static void Hc4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
static void Hc4_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{
UInt32 h2, h3;
UInt32 *hash;
uint32_t h2, h3;
uint32_t *hash;
SKIP_HEADER(4)
HASH4_CALC;
hash = p->hash;
@ -1047,12 +1047,12 @@ static void Hc4_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
}
/*
static void Hc5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
static void Hc5_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{
UInt32 h2, h3, h4;
UInt32 *hash;
uint32_t h2, h3, h4;
uint32_t *hash;
SKIP_HEADER(5)
HASH5_CALC;
hash = p->hash;
@ -1068,7 +1068,7 @@ static void Hc5_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
}
*/
void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num)
void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, uint32_t num)
{
do
{

66
deps/7zip/LzFind.h vendored
View File

@ -8,47 +8,47 @@
EXTERN_C_BEGIN
typedef UInt32 CLzRef;
typedef uint32_t CLzRef;
typedef struct _CMatchFinder
{
Byte *buffer;
UInt32 pos;
UInt32 posLimit;
UInt32 streamPos;
UInt32 lenLimit;
uint32_t pos;
uint32_t posLimit;
uint32_t streamPos;
uint32_t lenLimit;
UInt32 cyclicBufferPos;
UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */
uint32_t cyclicBufferPos;
uint32_t cyclicBufferSize; /* it must be = (historySize + 1) */
Byte streamEndWasReached;
Byte btMode;
Byte bigHash;
Byte directInput;
UInt32 matchMaxLen;
uint32_t matchMaxLen;
CLzRef *hash;
CLzRef *son;
UInt32 hashMask;
UInt32 cutValue;
uint32_t hashMask;
uint32_t cutValue;
Byte *bufferBase;
ISeqInStream *stream;
UInt32 blockSize;
UInt32 keepSizeBefore;
UInt32 keepSizeAfter;
uint32_t blockSize;
uint32_t keepSizeBefore;
uint32_t keepSizeAfter;
UInt32 numHashBytes;
uint32_t numHashBytes;
size_t directInputRem;
UInt32 historySize;
UInt32 fixedHashSize;
UInt32 hashSizeSum;
uint32_t historySize;
uint32_t fixedHashSize;
uint32_t hashSizeSum;
SRes result;
UInt32 crc[256];
uint32_t crc[256];
size_t numRefs;
UInt64 expectedDataSize;
uint64_t expectedDataSize;
} CMatchFinder;
#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((p)->buffer)
@ -71,16 +71,16 @@ void MatchFinder_Construct(CMatchFinder *p);
historySize <= 3 GB
keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB
*/
int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
int MatchFinder_Create(CMatchFinder *p, uint32_t historySize,
uint32_t keepAddBufferBefore, uint32_t matchMaxLen, uint32_t keepAddBufferAfter,
ISzAllocPtr alloc);
void MatchFinder_Free(CMatchFinder *p, ISzAllocPtr alloc);
void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, size_t numItems);
void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);
void MatchFinder_Normalize3(uint32_t subValue, CLzRef *items, size_t numItems);
void MatchFinder_ReduceOffsets(CMatchFinder *p, uint32_t subValue);
UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
UInt32 *distances, UInt32 maxLen);
uint32_t * GetMatchesSpec1(uint32_t lenLimit, uint32_t curMatch, uint32_t pos, const Byte *buffer, CLzRef *son,
uint32_t _cyclicBufferPos, uint32_t _cyclicBufferSize, uint32_t _cutValue,
uint32_t *distances, uint32_t maxLen);
/*
Conditions:
@ -89,10 +89,10 @@ Conditions:
*/
typedef void (*Mf_Init_Func)(void *object);
typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
typedef uint32_t (*Mf_GetNumAvailableBytes_Func)(void *object);
typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
typedef UInt32 (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
typedef void (*Mf_Skip_Func)(void *object, UInt32);
typedef uint32_t (*Mf_GetMatches_Func)(void *object, uint32_t *distances);
typedef void (*Mf_Skip_Func)(void *object, uint32_t);
typedef struct _IMatchFinder
{
@ -110,11 +110,11 @@ void MatchFinder_Init_HighHash(CMatchFinder *p);
void MatchFinder_Init_3(CMatchFinder *p, int readData);
void MatchFinder_Init(CMatchFinder *p);
UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
uint32_t Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances);
uint32_t Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, uint32_t *distances);
void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, uint32_t num);
void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, uint32_t num);
EXTERN_C_END

26
deps/7zip/LzHash.h vendored
View File

@ -12,45 +12,45 @@
#define kFix4HashSize (kHash2Size + kHash3Size)
#define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)
#define HASH2_CALC hv = cur[0] | ((UInt32)cur[1] << 8);
#define HASH2_CALC hv = cur[0] | ((uint32_t)cur[1] << 8);
#define HASH3_CALC { \
UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
uint32_t temp = p->crc[cur[0]] ^ cur[1]; \
h2 = temp & (kHash2Size - 1); \
hv = (temp ^ ((UInt32)cur[2] << 8)) & p->hashMask; }
hv = (temp ^ ((uint32_t)cur[2] << 8)) & p->hashMask; }
#define HASH4_CALC { \
UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
uint32_t temp = p->crc[cur[0]] ^ cur[1]; \
h2 = temp & (kHash2Size - 1); \
temp ^= ((UInt32)cur[2] << 8); \
temp ^= ((uint32_t)cur[2] << 8); \
h3 = temp & (kHash3Size - 1); \
hv = (temp ^ (p->crc[cur[3]] << 5)) & p->hashMask; }
#define HASH5_CALC { \
UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
uint32_t temp = p->crc[cur[0]] ^ cur[1]; \
h2 = temp & (kHash2Size - 1); \
temp ^= ((UInt32)cur[2] << 8); \
temp ^= ((uint32_t)cur[2] << 8); \
h3 = temp & (kHash3Size - 1); \
temp ^= (p->crc[cur[3]] << 5); \
h4 = temp & (kHash4Size - 1); \
hv = (temp ^ (p->crc[cur[4]] << 3)) & p->hashMask; }
/* #define HASH_ZIP_CALC hv = ((cur[0] | ((UInt32)cur[1] << 8)) ^ p->crc[cur[2]]) & 0xFFFF; */
#define HASH_ZIP_CALC hv = ((cur[2] | ((UInt32)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF;
/* #define HASH_ZIP_CALC hv = ((cur[0] | ((uint32_t)cur[1] << 8)) ^ p->crc[cur[2]]) & 0xFFFF; */
#define HASH_ZIP_CALC hv = ((cur[2] | ((uint32_t)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF;
#define MT_HASH2_CALC \
h2 = (p->crc[cur[0]] ^ cur[1]) & (kHash2Size - 1);
#define MT_HASH3_CALC { \
UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
uint32_t temp = p->crc[cur[0]] ^ cur[1]; \
h2 = temp & (kHash2Size - 1); \
h3 = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); }
h3 = (temp ^ ((uint32_t)cur[2] << 8)) & (kHash3Size - 1); }
#define MT_HASH4_CALC { \
UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
uint32_t temp = p->crc[cur[0]] ^ cur[1]; \
h2 = temp & (kHash2Size - 1); \
temp ^= ((UInt32)cur[2] << 8); \
temp ^= ((uint32_t)cur[2] << 8); \
h3 = temp & (kHash3Size - 1); \
h4 = (temp ^ (p->crc[cur[3]] << 5)) & (kHash4Size - 1); }

28
deps/7zip/Lzma2Dec.c vendored
View File

@ -32,7 +32,7 @@
#define LZMA2_IS_UNCOMPRESSED_STATE(p) (((p)->control & (1 << 7)) == 0)
#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
@ -56,7 +56,7 @@ typedef enum
static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)
{
UInt32 dicSize;
uint32_t dicSize;
if (prop > 40)
return SZ_ERROR_UNSUPPORTED;
dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);
@ -116,26 +116,26 @@ static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
if (b < p->needInitLevel)
return LZMA2_STATE_ERROR;
p->needInitLevel = 0;
p->unpackSize = (UInt32)(b & 0x1F) << 16;
p->unpackSize = (uint32_t)(b & 0x1F) << 16;
}
return LZMA2_STATE_UNPACK0;
case LZMA2_STATE_UNPACK0:
p->unpackSize |= (UInt32)b << 8;
p->unpackSize |= (uint32_t)b << 8;
return LZMA2_STATE_UNPACK1;
case LZMA2_STATE_UNPACK1:
p->unpackSize |= (UInt32)b;
p->unpackSize |= (uint32_t)b;
p->unpackSize++;
PRF(printf(" %7u", (unsigned)p->unpackSize));
return LZMA2_IS_UNCOMPRESSED_STATE(p) ? LZMA2_STATE_DATA : LZMA2_STATE_PACK0;
case LZMA2_STATE_PACK0:
p->packSize = (UInt32)b << 8;
p->packSize = (uint32_t)b << 8;
return LZMA2_STATE_PACK1;
case LZMA2_STATE_PACK1:
p->packSize |= (UInt32)b;
p->packSize |= (uint32_t)b;
p->packSize++;
/* if (p->packSize < 5) return LZMA2_STATE_ERROR; */
PRF(printf(" %5u", (unsigned)p->packSize));
@ -166,7 +166,7 @@ static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT s
p->dicPos += size;
if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)
p->checkDicSize = p->prop.dicSize;
p->processedPos += (UInt32)size;
p->processedPos += (uint32_t)size;
}
void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState);
@ -245,7 +245,7 @@ SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
src += inCur;
*srcLen += inCur;
p->unpackSize -= (UInt32)inCur;
p->unpackSize -= (uint32_t)inCur;
p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
}
else
@ -267,9 +267,9 @@ SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
src += inCur;
*srcLen += inCur;
p->packSize -= (UInt32)inCur;
p->packSize -= (uint32_t)inCur;
outCur = p->decoder.dicPos - dicPos;
p->unpackSize -= (UInt32)outCur;
p->unpackSize -= (uint32_t)outCur;
if (res != 0)
break;
@ -371,7 +371,7 @@ ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,
src += inCur;
*srcLen += inCur;
outSize -= inCur;
p->unpackSize -= (UInt32)inCur;
p->unpackSize -= (uint32_t)inCur;
p->state = (p->unpackSize == 0) ? LZMA2_STATE_CONTROL : LZMA2_STATE_DATA_CONT;
}
else
@ -400,7 +400,7 @@ ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,
src += inCur;
*srcLen += inCur;
p->packSize -= (UInt32)inCur;
p->packSize -= (uint32_t)inCur;
if (p->packSize == 0)
{
@ -408,7 +408,7 @@ ELzma2ParseStatus Lzma2Dec_Parse(CLzma2Dec *p,
if (rem > p->unpackSize)
rem = p->unpackSize;
p->decoder.dicPos += rem;
p->unpackSize -= (UInt32)rem;
p->unpackSize -= (uint32_t)rem;
outSize -= rem;
if (p->unpackSize == 0)
p->state = LZMA2_STATE_CONTROL;

4
deps/7zip/Lzma2Dec.h vendored
View File

@ -17,8 +17,8 @@ typedef struct
Byte needInitLevel;
Byte isExtraMode;
Byte _pad_;
UInt32 packSize;
UInt32 unpackSize;
uint32_t packSize;
uint32_t unpackSize;
CLzmaDec decoder;
} CLzma2Dec;

76
deps/7zip/LzmaDec.c vendored
View File

@ -9,7 +9,7 @@
#include "LzmaDec.h"
#define kNumTopBits 24
#define kTopValue ((UInt32)1 << kNumTopBits)
#define kTopValue ((uint32_t)1 << kNumTopBits)
#define kNumBitModelTotalBits 11
#define kBitModelTotal (1 << kNumBitModelTotalBits)
@ -19,7 +19,7 @@
#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }
#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)
#define IF_BIT_0(p) ttt = *(p); NORMALIZE; bound = (range >> kNumBitModelTotalBits) * (uint32_t)ttt; if (code < bound)
#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));
#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \
@ -66,7 +66,7 @@
#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_ERROR; range <<= 8; code = (code << 8) | (*buf++); }
#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * (UInt32)ttt; if (code < bound)
#define IF_BIT_0_CHECK(p) ttt = *(p); NORMALIZE_CHECK; bound = (range >> kNumBitModelTotalBits) * (uint32_t)ttt; if (code < bound)
#define UPDATE_0_CHECK range = bound;
#define UPDATE_1_CHECK range -= bound; code -= bound;
#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \
@ -155,7 +155,7 @@
#define LZMA_LIT_SIZE 0x300
#define LzmaProps_GetNumProbs(p) (NUM_BASE_PROBS + ((UInt32)LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
#define LzmaProps_GetNumProbs(p) (NUM_BASE_PROBS + ((uint32_t)LZMA_LIT_SIZE << ((p)->lc + (p)->lp)))
#define CALC_POS_STATE(processedPos, pbMask) (((processedPos) & (pbMask)) << 4)
@ -219,7 +219,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
{
CLzmaProb *probs = GET_PROBS;
unsigned state = (unsigned)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 lc = p->prop.lc;
unsigned lpMask = ((unsigned)0x100 << p->prop.lp) - ((unsigned)0x100 >> lc);
@ -228,18 +228,18 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
SizeT dicBufSize = p->dicBufSize;
SizeT dicPos = p->dicPos;
UInt32 processedPos = p->processedPos;
UInt32 checkDicSize = p->checkDicSize;
uint32_t processedPos = p->processedPos;
uint32_t checkDicSize = p->checkDicSize;
unsigned len = 0;
const Byte *buf = p->buf;
UInt32 range = p->range;
UInt32 code = p->code;
uint32_t range = p->range;
uint32_t code = p->code;
do
{
CLzmaProb *prob;
UInt32 bound;
uint32_t bound;
unsigned ttt;
unsigned posState = CALC_POS_STATE(processedPos, pbMask);
@ -250,7 +250,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
UPDATE_0(prob);
prob = probs + Literal;
if (processedPos != 0 || checkDicSize != 0)
prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
prob += (uint32_t)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);
processedPos++;
if (state < kNumLitStates)
@ -339,7 +339,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
}
else
{
UInt32 distance;
uint32_t distance;
UPDATE_1(prob);
prob = probs + IsRepG1 + state;
IF_BIT_0(prob)
@ -443,7 +443,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
if (state >= kNumStates)
{
UInt32 distance;
uint32_t distance;
prob = probs + PosSlot +
((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);
TREE_6_DECODE(prob, distance);
@ -457,7 +457,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
distance <<= numDirectBits;
prob = probs + SpecPos;
{
UInt32 m = 1;
uint32_t m = 1;
distance++;
do
{
@ -476,9 +476,9 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
range >>= 1;
{
UInt32 t;
uint32_t t;
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);
code += range & t;
}
@ -502,7 +502,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
REV_BIT_LAST (prob, i, 8);
distance |= i;
}
if (distance == (UInt32)0xFFFFFFFF)
if (distance == (uint32_t)0xFFFFFFFF)
{
len = kMatchSpecLenStart;
state -= kNumStates;
@ -539,7 +539,7 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
curLen = ((rem < len) ? (unsigned)rem : len);
pos = dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0);
processedPos += (UInt32)curLen;
processedPos += (uint32_t)curLen;
len -= curLen;
if (curLen <= dicBufSize - pos)
@ -572,14 +572,14 @@ int MY_FAST_CALL LZMA_DECODE_REAL(CLzmaDec *p, SizeT limit, const Byte *bufLimit
p->buf = buf;
p->range = range;
p->code = code;
p->remainLen = (UInt32)len;
p->remainLen = (uint32_t)len;
p->dicPos = dicPos;
p->processedPos = processedPos;
p->reps[0] = rep0;
p->reps[1] = rep1;
p->reps[2] = rep2;
p->reps[3] = rep3;
p->state = (UInt32)state;
p->state = (uint32_t)state;
return SZ_OK;
}
@ -601,8 +601,8 @@ static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
p->checkDicSize = p->prop.dicSize;
p->processedPos += (UInt32)len;
p->remainLen -= (UInt32)len;
p->processedPos += (uint32_t)len;
p->remainLen -= (uint32_t)len;
while (len != 0)
{
len--;
@ -628,7 +628,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte
SizeT limit2 = limit;
if (p->checkDicSize == 0)
{
UInt32 rem = p->prop.dicSize - p->processedPos;
uint32_t rem = p->prop.dicSize - p->processedPos;
if (limit - p->dicPos > rem)
limit2 = p->dicPos + rem;
@ -659,8 +659,8 @@ typedef enum
static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
{
UInt32 range = p->range;
UInt32 code = p->code;
uint32_t range = p->range;
uint32_t code = p->code;
const Byte *bufLimit = buf + inSize;
const CLzmaProb *probs = GET_PROBS;
unsigned state = (unsigned)p->state;
@ -668,7 +668,7 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
{
const CLzmaProb *prob;
UInt32 bound;
uint32_t bound;
unsigned ttt;
unsigned posState = CALC_POS_STATE(p->processedPos, (1 << p->prop.pb) - 1);
@ -681,7 +681,7 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
prob = probs + Literal;
if (p->checkDicSize != 0 || p->processedPos != 0)
prob += ((UInt32)LZMA_LIT_SIZE *
prob += ((uint32_t)LZMA_LIT_SIZE *
((((p->processedPos) & ((1 << (p->prop.lp)) - 1)) << p->prop.lc) +
(p->dic[(p->dicPos == 0 ? p->dicBufSize : p->dicPos) - 1] >> (8 - p->prop.lc))));
@ -892,10 +892,10 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
return SZ_OK;
}
p->code =
((UInt32)p->tempBuf[1] << 24)
| ((UInt32)p->tempBuf[2] << 16)
| ((UInt32)p->tempBuf[3] << 8)
| ((UInt32)p->tempBuf[4]);
((uint32_t)p->tempBuf[1] << 24)
| ((uint32_t)p->tempBuf[2] << 16)
| ((uint32_t)p->tempBuf[3] << 8)
| ((uint32_t)p->tempBuf[4]);
p->range = 0xFFFFFFFF;
p->tempBufSize = 0;
@ -1079,13 +1079,13 @@ void LzmaDec_Free(CLzmaDec *p, ISzAllocPtr alloc)
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
{
UInt32 dicSize;
uint32_t dicSize;
Byte d;
if (size < LZMA_PROPS_SIZE)
return SZ_ERROR_UNSUPPORTED;
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)
dicSize = LZMA_DIC_MIN;
@ -1105,7 +1105,7 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAllocPtr alloc)
{
UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
uint32_t numProbs = LzmaProps_GetNumProbs(propNew);
if (!p->probs || numProbs != p->numProbs)
{
LzmaDec_FreeProbs(p, alloc);
@ -1135,10 +1135,10 @@ SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAll
RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc));
{
UInt32 dictSize = propNew.dicSize;
SizeT mask = ((UInt32)1 << 12) - 1;
if (dictSize >= ((UInt32)1 << 30)) mask = ((UInt32)1 << 22) - 1;
else if (dictSize >= ((UInt32)1 << 22)) mask = ((UInt32)1 << 20) - 1;;
uint32_t dictSize = propNew.dicSize;
SizeT mask = ((uint32_t)1 << 12) - 1;
if (dictSize >= ((uint32_t)1 << 30)) mask = ((uint32_t)1 << 22) - 1;
else if (dictSize >= ((uint32_t)1 << 22)) mask = ((uint32_t)1 << 20) - 1;;
dicBufSize = ((SizeT)dictSize + mask) & ~mask;
if (dicBufSize < dictSize)
dicBufSize = dictSize;

22
deps/7zip/LzmaDec.h vendored
View File

@ -14,9 +14,9 @@ EXTERN_C_BEGIN
typedef
#ifdef _LZMA_PROB32
UInt32
uint32_t
#else
UInt16
uint16_t
#endif
CLzmaProb;
@ -31,7 +31,7 @@ typedef struct _CLzmaProps
Byte lp;
Byte pb;
Byte _pad_;
UInt32 dicSize;
uint32_t dicSize;
} CLzmaProps;
/* LzmaProps_Decode - decodes properties
@ -60,15 +60,15 @@ typedef struct
SizeT dicBufSize;
SizeT dicPos;
const Byte *buf;
UInt32 range;
UInt32 code;
UInt32 processedPos;
UInt32 checkDicSize;
UInt32 reps[4];
UInt32 state;
UInt32 remainLen;
uint32_t range;
uint32_t code;
uint32_t processedPos;
uint32_t checkDicSize;
uint32_t reps[4];
uint32_t state;
uint32_t remainLen;
UInt32 numProbs;
uint32_t numProbs;
unsigned tempBufSize;
Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];
} CLzmaDec;

368
deps/7zip/LzmaEnc.c vendored
View File

File diff suppressed because it is too large Load Diff

10
deps/7zip/LzmaEnc.h vendored
View File

@ -13,7 +13,7 @@ EXTERN_C_BEGIN
typedef struct _CLzmaEncProps
{
int level; /* 0 <= level <= 9 */
UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
uint32_t dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
(1 << 12) <= dictSize <= (3 << 29) for 64-bit version
default = (1 << 24) */
int lc; /* 0 <= lc <= 8, default = 3 */
@ -23,17 +23,17 @@ typedef struct _CLzmaEncProps
int fb; /* 5 <= fb <= 273, default = 32 */
int btMode; /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
int numHashBytes; /* 2, 3 or 4, default = 4 */
UInt32 mc; /* 1 <= mc <= (1 << 30), default = 32 */
uint32_t mc; /* 1 <= mc <= (1 << 30), default = 32 */
unsigned writeEndMark; /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
int numThreads; /* 1 or 2, default = 2 */
UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1.
uint64_t reduceSize; /* estimated size of data that will be compressed. default = (uint64_t)(Int64)-1.
Encoder uses this value to reduce dictionary size */
} CLzmaEncProps;
void LzmaEncProps_Init(CLzmaEncProps *p);
void LzmaEncProps_Normalize(CLzmaEncProps *p);
UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
uint32_t LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
/* ---------- CLzmaEncHandle Interface ---------- */
@ -55,7 +55,7 @@ CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc);
void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig);
SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize);
void LzmaEnc_SetDataSize(CLzmaEncHandle p, uint64_t expectedDataSiize);
SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p);

4
libretro-common/file/archive_file_7z.c
View File

@ -59,7 +59,7 @@ struct sevenzip_context_t
uint32_t parse_index;
uint32_t decompress_index;
uint32_t packIndex;
UInt32 block_index;
uint32_t block_index;
};
static void *sevenzip_stream_alloc_impl(ISzAllocPtr p, size_t size)
@ -200,7 +200,7 @@ static int64_t sevenzip_file_read(
bool file_found = false;
uint16_t *temp = NULL;
size_t temp_size = 0;
UInt32 block_index = 0xFFFFFFFF;
uint32_t block_index = 0xFFFFFFFF;
SRes res = SZ_OK;
for (i = 0; i < db.NumFiles; i++)