empathicqubit/Mesen-SX
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Reformat SevenZip (Resharper)

Browse source
This commit is contained in:
Vladimir Kononovich 2020-12-19 23:32:06 +03:00
parent 4925698573
commit 68c88a6b7c
35 changed files with 5095 additions and 5064 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

81
SevenZip/7z.h
View file

@ -15,7 +15,7 @@ extern const Byte k7zSignature[k7zSignatureSize];
typedef struct
{
const Byte *Data;
const Byte* Data;
size_t Size;
} CSzData;
@ -51,7 +51,7 @@ typedef struct
} CSzFolder;
SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd);
SRes SzGetNextFolderItem(CSzFolder* f, CSzData* sd);
typedef struct
{
@ -61,15 +61,15 @@ typedef struct
typedef struct
{
Byte *Defs; /* MSB 0 bit numbering */
UInt32 *Vals;
Byte* Defs; /* MSB 0 bit numbering */
UInt32* Vals;
} CSzBitUi32s;
typedef struct
{
Byte *Defs; /* MSB 0 bit numbering */
Byte* Defs; /* MSB 0 bit numbering */
// UInt64 *Vals;
CNtfsFileTime *Vals;
CNtfsFileTime* Vals;
} CSzBitUi64s;
#define SzBitArray_Check(p, i) (((p)[(i) >> 3] & (0x80 >> ((i) & 7))) != 0)
@ -81,24 +81,24 @@ typedef struct
UInt32 NumPackStreams;
UInt32 NumFolders;
UInt64 *PackPositions; // NumPackStreams + 1
UInt64* PackPositions; // NumPackStreams + 1
CSzBitUi32s FolderCRCs; // NumFolders
size_t *FoCodersOffsets; // NumFolders + 1
UInt32 *FoStartPackStreamIndex; // NumFolders + 1
UInt32 *FoToCoderUnpackSizes; // NumFolders + 1
Byte *FoToMainUnpackSizeIndex; // NumFolders
UInt64 *CoderUnpackSizes; // for all coders in all folders
size_t* FoCodersOffsets; // NumFolders + 1
UInt32* FoStartPackStreamIndex; // NumFolders + 1
UInt32* FoToCoderUnpackSizes; // NumFolders + 1
Byte* FoToMainUnpackSizeIndex; // NumFolders
UInt64* CoderUnpackSizes; // for all coders in all folders
Byte *CodersData;
Byte* CodersData;
} CSzAr;
UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex);
UInt64 SzAr_GetFolderUnpackSize(const CSzAr* p, UInt32 folderIndex);
SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
ILookInStream *stream, UInt64 startPos,
Byte *outBuffer, size_t outSize,
ISzAlloc *allocMain);
SRes SzAr_DecodeFolder(const CSzAr* p, UInt32 folderIndex,
ILookInStream* stream, UInt64 startPos,
Byte* outBuffer, size_t outSize,
ISzAlloc* allocMain);
typedef struct
{
@ -109,9 +109,9 @@ typedef struct
UInt32 NumFiles;
UInt64 *UnpackPositions; // NumFiles + 1
UInt64* UnpackPositions; // NumFiles + 1
// Byte *IsEmptyFiles;
Byte *IsDirs;
Byte* IsDirs;
CSzBitUi32s CRCs;
CSzBitUi32s Attribs;
@ -119,21 +119,21 @@ typedef struct
CSzBitUi64s MTime;
CSzBitUi64s CTime;
UInt32 *FolderToFile; // NumFolders + 1
UInt32 *FileToFolder; // NumFiles
UInt32* FolderToFile; // NumFolders + 1
UInt32* FileToFolder; // NumFiles
size_t *FileNameOffsets; /* in 2-byte steps */
Byte *FileNames; /* UTF-16-LE */
size_t* FileNameOffsets; /* in 2-byte steps */
Byte* FileNames; /* UTF-16-LE */
} CSzArEx;
#define SzArEx_IsDir(p, i) (SzBitArray_Check((p)->IsDirs, i))
#define SzArEx_GetFileSize(p, i) ((p)->UnpackPositions[(i) + 1] - (p)->UnpackPositions[i])
void SzArEx_Init(CSzArEx *p);
void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc);
UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
void SzArEx_Init(CSzArEx* p);
void SzArEx_Free(CSzArEx* p, ISzAlloc* alloc);
UInt64 SzArEx_GetFolderStreamPos(const CSzArEx* p, UInt32 folderIndex, UInt32 indexInFolder);
int SzArEx_GetFolderFullPackSize(const CSzArEx* p, UInt32 folderIndex, UInt64* resSize);
/*
if dest == NULL, the return value specifies the required size of the buffer,
@ -141,7 +141,7 @@ 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* dest);
/*
size_t SzArEx_GetFullNameLen(const CSzArEx *p, size_t fileIndex);
@ -149,7 +149,6 @@ UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16
*/
/*
SzArEx_Extract extracts file from archive
@ -171,16 +170,16 @@ UInt16 *SzArEx_GetFullNameUtf16_Back(const CSzArEx *p, size_t fileIndex, UInt16
*/
SRes SzArEx_Extract(
const CSzArEx *db,
ILookInStream *inStream,
const CSzArEx* db,
ILookInStream* inStream,
UInt32 fileIndex, /* index of file */
UInt32 *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 */
size_t *outSizeProcessed, /* size of file in *outBuffer */
ISzAlloc *allocMain,
ISzAlloc *allocTemp);
UInt32* 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 */
size_t* outSizeProcessed, /* size of file in *outBuffer */
ISzAlloc* allocMain,
ISzAlloc* allocTemp);
/*
@ -194,8 +193,8 @@ SZ_ERROR_INPUT_EOF
SZ_ERROR_FAIL
*/
SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
ISzAlloc *allocMain, ISzAlloc *allocTemp);
SRes SzArEx_Open(CSzArEx* p, ILookInStream* inStream,
ISzAlloc* allocMain, ISzAlloc* allocTemp);
EXTERN_C_END

32
SevenZip/7zAlloc.c
View file

@ -20,59 +20,59 @@ int g_allocCountTemp = 0;
#endif
void *SzAlloc(void *p, size_t size)
void* SzAlloc(void* p, size_t size)
{
UNUSED_VAR(p);
if (size == 0)
return 0;
#ifdef _SZ_ALLOC_DEBUG
#ifdef _SZ_ALLOC_DEBUG
fprintf(stderr, "\nAlloc %10u bytes; count = %10d", (unsigned)size, g_allocCount);
g_allocCount++;
#endif
#endif
return malloc(size);
}
void SzFree(void *p, void *address)
void SzFree(void* p, void* address)
{
UNUSED_VAR(p);
#ifdef _SZ_ALLOC_DEBUG
#ifdef _SZ_ALLOC_DEBUG
if (address != 0)
{
g_allocCount--;
fprintf(stderr, "\nFree; count = %10d", g_allocCount);
}
#endif
#endif
free(address);
}
void *SzAllocTemp(void *p, size_t size)
void* SzAllocTemp(void* p, size_t size)
{
UNUSED_VAR(p);
if (size == 0)
return 0;
#ifdef _SZ_ALLOC_DEBUG
#ifdef _SZ_ALLOC_DEBUG
fprintf(stderr, "\nAlloc_temp %10u bytes; count = %10d", (unsigned)size, g_allocCountTemp);
g_allocCountTemp++;
#ifdef _WIN32
#ifdef _WIN32
return HeapAlloc(GetProcessHeap(), 0, size);
#endif
#endif
#endif
#endif
return malloc(size);
}
void SzFreeTemp(void *p, void *address)
void SzFreeTemp(void* p, void* address)
{
UNUSED_VAR(p);
#ifdef _SZ_ALLOC_DEBUG
#ifdef _SZ_ALLOC_DEBUG
if (address != 0)
{
g_allocCountTemp--;
fprintf(stderr, "\nFree_temp; count = %10d", g_allocCountTemp);
}
#ifdef _WIN32
#ifdef _WIN32
HeapFree(GetProcessHeap(), 0, address);
return;
#endif
#endif
#endif
#endif
free(address);
}

8
SevenZip/7zAlloc.h
View file

@ -10,11 +10,11 @@
extern "C" {
#endif
void *SzAlloc(void *p, size_t size);
void SzFree(void *p, void *address);
void* SzAlloc(void* p, size_t size);
void SzFree(void* p, void* address);
void *SzAllocTemp(void *p, size_t size);
void SzFreeTemp(void *p, void *address);
void* SzAllocTemp(void* p, size_t size);
void SzFreeTemp(void* p, void* address);
#ifdef __cplusplus
}

219
SevenZip/7zArcIn.c
View file

@ -60,7 +60,7 @@ const Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};
#define SzBitUi32s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }
static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAlloc *alloc)
static SRes SzBitUi32s_Alloc(CSzBitUi32s* p, size_t num, ISzAlloc* alloc)
{
if (num == 0)
{
@ -75,22 +75,26 @@ static SRes SzBitUi32s_Alloc(CSzBitUi32s *p, size_t num, ISzAlloc *alloc)
return SZ_OK;
}
void SzBitUi32s_Free(CSzBitUi32s *p, ISzAlloc *alloc)
void SzBitUi32s_Free(CSzBitUi32s* p, ISzAlloc* alloc)
{
IAlloc_Free(alloc, p->Defs); p->Defs = NULL;
IAlloc_Free(alloc, p->Vals); p->Vals = NULL;
IAlloc_Free(alloc, p->Defs);
p->Defs = NULL;
IAlloc_Free(alloc, p->Vals);
p->Vals = NULL;
}
#define SzBitUi64s_Init(p) { (p)->Defs = NULL; (p)->Vals = NULL; }
void SzBitUi64s_Free(CSzBitUi64s *p, ISzAlloc *alloc)
void SzBitUi64s_Free(CSzBitUi64s* p, ISzAlloc* alloc)
{
IAlloc_Free(alloc, p->Defs); p->Defs = NULL;
IAlloc_Free(alloc, p->Vals); p->Vals = NULL;
IAlloc_Free(alloc, p->Defs);
p->Defs = NULL;
IAlloc_Free(alloc, p->Vals);
p->Vals = NULL;
}
static void SzAr_Init(CSzAr *p)
static void SzAr_Init(CSzAr* p)
{
p->NumPackStreams = 0;
p->NumFolders = 0;
@ -107,7 +111,7 @@ static void SzAr_Init(CSzAr *p)
p->CodersData = NULL;
}
static void SzAr_Free(CSzAr *p, ISzAlloc *alloc)
static void SzAr_Free(CSzAr* p, ISzAlloc* alloc)
{
IAlloc_Free(alloc, p->PackPositions);
SzBitUi32s_Free(&p->FolderCRCs, alloc);
@ -124,7 +128,7 @@ static void SzAr_Free(CSzAr *p, ISzAlloc *alloc)
}
void SzArEx_Init(CSzArEx *p)
void SzArEx_Init(CSzArEx* p)
{
SzAr_Init(&p->db);
@ -147,7 +151,7 @@ void SzArEx_Init(CSzArEx *p)
SzBitUi64s_Init(&p->CTime);
}
void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc)
void SzArEx_Free(CSzArEx* p, ISzAlloc* alloc)
{
IAlloc_Free(alloc, p->UnpackPositions);
IAlloc_Free(alloc, p->IsDirs);
@ -169,7 +173,7 @@ void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc)
}
static int TestSignatureCandidate(const Byte *testBytes)
static int TestSignatureCandidate(const Byte* testBytes)
{
unsigned i;
for (i = 0; i < k7zSignatureSize; i++)
@ -190,7 +194,7 @@ 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* value)
{
Byte firstByte, mask;
unsigned i;
@ -228,7 +232,7 @@ static MY_NO_INLINE SRes ReadNumber(CSzData *sd, UInt64 *value)
}
static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
static MY_NO_INLINE SRes SzReadNumber32(CSzData* sd, UInt32* value)
{
Byte firstByte;
UInt64 value64;
@ -253,7 +257,7 @@ static MY_NO_INLINE SRes SzReadNumber32(CSzData *sd, UInt32 *value)
#define ReadID(sd, value) ReadNumber(sd, value)
static SRes SkipData(CSzData *sd)
static SRes SkipData(CSzData* sd)
{
UInt64 size;
RINOK(ReadNumber(sd, &size));
@ -263,7 +267,7 @@ static SRes SkipData(CSzData *sd)
return SZ_OK;
}
static SRes WaitId(CSzData *sd, UInt32 id)
static SRes WaitId(CSzData* sd, UInt32 id)
{
for (;;)
{
@ -277,7 +281,7 @@ static SRes WaitId(CSzData *sd, UInt32 id)
}
}
static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)
static SRes RememberBitVector(CSzData* sd, UInt32 numItems, const Byte** v)
{
UInt32 numBytes = (numItems + 7) >> 3;
if (numBytes > sd->Size)
@ -287,7 +291,7 @@ static SRes RememberBitVector(CSzData *sd, UInt32 numItems, const Byte **v)
return SZ_OK;
}
static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
static UInt32 CountDefinedBits(const Byte* bits, UInt32 numItems)
{
Byte b = 0;
unsigned m = 0;
@ -305,10 +309,10 @@ static UInt32 CountDefinedBits(const Byte *bits, UInt32 numItems)
return sum;
}
static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, ISzAlloc *alloc)
static MY_NO_INLINE SRes ReadBitVector(CSzData* sd, UInt32 numItems, Byte** v, ISzAlloc* alloc)
{
Byte allAreDefined;
Byte *v2;
Byte* v2;
UInt32 numBytes = (numItems + 7) >> 3;
*v = NULL;
SZ_READ_BYTE(allAreDefined);
@ -333,12 +337,12 @@ static MY_NO_INLINE SRes ReadBitVector(CSzData *sd, UInt32 numItems, Byte **v, I
return SZ_OK;
}
static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)
static MY_NO_INLINE SRes ReadUi32s(CSzData* sd2, UInt32 numItems, CSzBitUi32s* crcs, ISzAlloc* alloc)
{
UInt32 i;
CSzData sd;
UInt32 *vals;
const Byte *defs;
UInt32* vals;
const Byte* defs;
MY_ALLOC_ZE(UInt32, crcs->Vals, numItems, alloc);
sd = *sd2;
defs = crcs->Defs;
@ -354,14 +358,14 @@ static MY_NO_INLINE SRes ReadUi32s(CSzData *sd2, UInt32 numItems, CSzBitUi32s *c
return SZ_OK;
}
static SRes ReadBitUi32s(CSzData *sd, UInt32 numItems, CSzBitUi32s *crcs, ISzAlloc *alloc)
static SRes ReadBitUi32s(CSzData* sd, UInt32 numItems, CSzBitUi32s* crcs, ISzAlloc* alloc)
{
SzBitUi32s_Free(crcs, alloc);
RINOK(ReadBitVector(sd, numItems, &crcs->Defs, alloc));
return ReadUi32s(sd, numItems, crcs, alloc);
}
static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
static SRes SkipBitUi32s(CSzData* sd, UInt32 numItems)
{
Byte allAreDefined;
UInt32 numDefined = numItems;
@ -380,7 +384,7 @@ static SRes SkipBitUi32s(CSzData *sd, UInt32 numItems)
return SZ_OK;
}
static SRes ReadPackInfo(CSzAr *p, CSzData *sd, ISzAlloc *alloc)
static SRes ReadPackInfo(CSzAr* p, CSzData* sd, ISzAlloc* alloc)
{
RINOK(SzReadNumber32(sd, &p->NumPackStreams));
@ -429,11 +433,11 @@ static SRes SzReadSwitch(CSzData *sd)
#define k_NumCodersStreams_in_Folder_MAX (SZ_NUM_BONDS_IN_FOLDER_MAX + SZ_NUM_PACK_STREAMS_IN_FOLDER_MAX)
SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
SRes SzGetNextFolderItem(CSzFolder* f, CSzData* sd)
{
UInt32 numCoders, i;
UInt32 numInStreams = 0;
const Byte *dataStart = sd->Data;
const Byte* dataStart = sd->Data;
f->NumCoders = 0;
f->NumBonds = 0;
@ -447,7 +451,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
for (i = 0; i < numCoders; i++)
{
Byte mainByte;
CSzCoderInfo *coder = f->Coders + i;
CSzCoderInfo* coder = f->Coders + i;
unsigned idSize, j;
UInt64 id;
@ -545,7 +549,7 @@ SRes SzGetNextFolderItem(CSzFolder *f, CSzData *sd)
for (i = 0; i < numBonds; i++)
{
CSzBond *bp = f->Bonds + i;
CSzBond* bp = f->Bonds + i;
RINOK(SzReadNumber32(sd, &bp->InIndex));
if (bp->InIndex >= numInStreams || streamUsed[bp->InIndex])
@ -596,7 +600,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 num)
{
CSzData sd;
sd = *sd2;
@ -631,16 +635,16 @@ static MY_NO_INLINE SRes SkipNumbers(CSzData *sd2, UInt32 num)
#define k_Scan_NumCodersStreams_in_Folder_MAX 64
static SRes ReadUnpackInfo(CSzAr *p,
CSzData *sd2,
static SRes ReadUnpackInfo(CSzAr* p,
CSzData* sd2,
UInt32 numFoldersMax,
const CBuf *tempBufs, UInt32 numTempBufs,
ISzAlloc *alloc)
const CBuf* tempBufs, UInt32 numTempBufs,
ISzAlloc* alloc)
{
CSzData sd;
UInt32 fo, numFolders, numCodersOutStreams, packStreamIndex;
const Byte *startBufPtr;
const Byte* startBufPtr;
Byte external;
RINOK(WaitId(sd2, k7zIdFolder));
@ -840,7 +844,7 @@ static SRes ReadUnpackInfo(CSzAr *p,
}
UInt64 SzAr_GetFolderUnpackSize(const CSzAr *p, UInt32 folderIndex)
UInt64 SzAr_GetFolderUnpackSize(const CSzAr* p, UInt32 folderIndex)
{
return p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex] + p->FoToMainUnpackSizeIndex[folderIndex]];
}
@ -856,7 +860,7 @@ typedef struct
} CSubStreamInfo;
static SRes ReadSubStreamsInfo(CSzAr *p, CSzData *sd, CSubStreamInfo *ssi)
static SRes ReadSubStreamsInfo(CSzAr* p, CSzData* sd, CSubStreamInfo* ssi)
{
UInt64 type = 0;
UInt32 numSubDigests = 0;
@ -929,12 +933,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,
CSubStreamInfo *ssi,
ISzAlloc *alloc)
static SRes SzReadStreamsInfo(CSzAr* p,
CSzData* sd,
UInt32 numFoldersMax, const CBuf* tempBufs, UInt32 numTempBufs,
UInt64* dataOffset,
CSubStreamInfo* ssi,
ISzAlloc* alloc)
{
UInt64 type;
@ -970,13 +974,13 @@ static SRes SzReadStreamsInfo(CSzAr *p,
}
static SRes SzReadAndDecodePackedStreams(
ILookInStream *inStream,
CSzData *sd,
CBuf *tempBufs,
ILookInStream* inStream,
CSzData* sd,
CBuf* tempBufs,
UInt32 numFoldersMax,
UInt64 baseOffset,
CSzAr *p,
ISzAlloc *allocTemp)
CSzAr* p,
ISzAlloc* allocTemp)
{
UInt64 dataStartPos;
UInt32 fo;
@ -993,7 +997,7 @@ static SRes SzReadAndDecodePackedStreams(
for (fo = 0; fo < p->NumFolders; fo++)
{
CBuf *tempBuf = tempBufs + fo;
CBuf* tempBuf = tempBufs + fo;
UInt64 unpackSize = SzAr_GetFolderUnpackSize(p, fo);
if ((size_t)unpackSize != unpackSize)
return SZ_ERROR_MEM;
@ -1003,7 +1007,7 @@ static SRes SzReadAndDecodePackedStreams(
for (fo = 0; fo < p->NumFolders; fo++)
{
const CBuf *tempBuf = tempBufs + fo;
const CBuf* tempBuf = tempBufs + fo;
RINOK(LookInStream_SeekTo(inStream, dataStartPos));
RINOK(SzAr_DecodeFolder(p, fo, inStream, dataStartPos, tempBuf->data, tempBuf->size, allocTemp));
}
@ -1011,7 +1015,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 numFiles, size_t* offsets)
{
size_t pos = 0;
*offsets++ = 0;
@ -1023,15 +1027,15 @@ static SRes SzReadFileNames(const Byte *data, size_t size, UInt32 numFiles, size
return SZ_ERROR_ARCHIVE;
do
{
const Byte *p;
const Byte* p;
if (pos == size)
return SZ_ERROR_ARCHIVE;
for (p = data + pos;
#ifdef _WIN32
*(const UInt16 *)p != 0
#else
#ifdef _WIN32
*(const UInt16*)p != 0
#else
p[0] != 0 || p[1] != 0
#endif
#endif
; p += 2);
pos = p - data + 2;
*offsets++ = (pos >> 1);
@ -1040,15 +1044,15 @@ 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,
CSzData *sd2,
const CBuf *tempBufs, UInt32 numTempBufs,
ISzAlloc *alloc)
static MY_NO_INLINE SRes ReadTime(CSzBitUi64s* p, UInt32 num,
CSzData* sd2,
const CBuf* tempBufs, UInt32 numTempBufs,
ISzAlloc* alloc)
{
CSzData sd;
UInt32 i;
CNtfsFileTime *vals;
Byte *defs;
CNtfsFileTime* vals;
Byte* defs;
Byte external;
RINOK(ReadBitVector(sd2, num, &p->Defs, alloc));
@ -1092,17 +1096,17 @@ static MY_NO_INLINE SRes ReadTime(CSzBitUi64s *p, UInt32 num,
static SRes SzReadHeader2(
CSzArEx *p, /* allocMain */
CSzData *sd,
ILookInStream *inStream,
CBuf *tempBufs, UInt32 *numTempBufs,
ISzAlloc *allocMain,
ISzAlloc *allocTemp
)
CSzArEx* p, /* allocMain */
CSzData* sd,
ILookInStream* inStream,
CBuf* tempBufs, UInt32* numTempBufs,
ISzAlloc* allocMain,
ISzAlloc* allocTemp
)
{
CSubStreamInfo ssi;
{
{
UInt64 type;
SzData_Clear(&ssi.sdSizes);
@ -1158,13 +1162,13 @@ static SRes SzReadHeader2(
if (type != k7zIdFilesInfo)
return SZ_ERROR_ARCHIVE;
}
}
{
{
UInt32 numFiles = 0;
UInt32 numEmptyStreams = 0;
const Byte *emptyStreams = NULL;
const Byte *emptyFiles = NULL;
const Byte* emptyStreams = NULL;
const Byte* emptyFiles = NULL;
RINOK(SzReadNumber32(sd, &numFiles));
p->NumFiles = numFiles;
@ -1184,12 +1188,13 @@ static SRes SzReadHeader2(
{
SKIP_DATA(sd, size);
}
else switch ((unsigned)type)
else
switch ((unsigned)type)
{
case k7zIdName:
{
size_t namesSize;
const Byte *namesData;
const Byte* namesData;
Byte external;
SZ_READ_BYTE(external);
@ -1235,7 +1240,7 @@ static SRes SzReadHeader2(
{
Byte external;
CSzData sdSwitch;
CSzData *sdPtr;
CSzData* sdPtr;
SzBitUi32s_Free(&p->Attribs, allocMain);
RINOK(ReadBitVector(sd, numFiles, &p->Attribs.Defs, allocMain));
@ -1265,8 +1270,10 @@ static SRes SzReadHeader2(
break;
}
*/
case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain)); break;
case k7zIdMTime: RINOK(ReadTime(&p->MTime, numFiles, sd, tempBufs, *numTempBufs, allocMain));
break;
case k7zIdCTime: RINOK(ReadTime(&p->CTime, numFiles, sd, tempBufs, *numTempBufs, allocMain));
break;
default:
{
SKIP_DATA(sd, size);
@ -1293,8 +1300,8 @@ static SRes SzReadHeader2(
UInt32 remSubStreams = 0;
UInt32 numSubStreams = 0;
UInt64 unpackPos = 0;
const Byte *digestsDefs = NULL;
const Byte *digestsVals = NULL;
const Byte* digestsDefs = NULL;
const Byte* digestsVals = NULL;
UInt32 digestsValsIndex = 0;
UInt32 digestIndex;
Byte allDigestsDefined = 0;
@ -1463,17 +1470,17 @@ static SRes SzReadHeader2(
if (ssi.sdNumSubStreams.Data && ssi.sdNumSubStreams.Size != 0)
return SZ_ERROR_ARCHIVE;
}
}
}
return SZ_OK;
}
static SRes SzReadHeader(
CSzArEx *p,
CSzData *sd,
ILookInStream *inStream,
ISzAlloc *allocMain,
ISzAlloc *allocTemp)
CSzArEx* p,
CSzData* sd,
ILookInStream* inStream,
ISzAlloc* allocMain,
ISzAlloc* allocTemp)
{
UInt32 i;
UInt32 numTempBufs = 0;
@ -1499,10 +1506,10 @@ static SRes SzReadHeader(
}
static SRes SzArEx_Open2(
CSzArEx *p,
ILookInStream *inStream,
ISzAlloc *allocMain,
ISzAlloc *allocTemp)
CSzArEx* p,
ILookInStream* inStream,
ISzAlloc* allocMain,
ISzAlloc* allocTemp)
{
Byte header[k7zStartHeaderSize];
Int64 startArcPos;
@ -1622,8 +1629,8 @@ static SRes SzArEx_Open2(
}
SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
ISzAlloc *allocMain, ISzAlloc *allocTemp)
SRes SzArEx_Open(CSzArEx* p, ILookInStream* inStream,
ISzAlloc* allocMain, ISzAlloc* allocTemp)
{
SRes res = SzArEx_Open2(p, inStream, allocMain, allocTemp);
if (res != SZ_OK)
@ -1633,16 +1640,16 @@ SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream,
SRes SzArEx_Extract(
const CSzArEx *p,
ILookInStream *inStream,
const CSzArEx* p,
ILookInStream* inStream,
UInt32 fileIndex,
UInt32 *blockIndex,
Byte **tempBuf,
size_t *outBufferSize,
size_t *offset,
size_t *outSizeProcessed,
ISzAlloc *allocMain,
ISzAlloc *allocTemp)
UInt32* blockIndex,
Byte** tempBuf,
size_t* outBufferSize,
size_t* offset,
size_t* outSizeProcessed,
ISzAlloc* allocMain,
ISzAlloc* allocTemp)
{
UInt32 folderIndex = p->FileToFolder[fileIndex];
SRes res = SZ_OK;
@ -1680,7 +1687,7 @@ SRes SzArEx_Extract(
*outBufferSize = unpackSize;
if (unpackSize != 0)
{
*tempBuf = (Byte *)IAlloc_Alloc(allocMain, unpackSize);
*tempBuf = (Byte*)IAlloc_Alloc(allocMain, unpackSize);
if (*tempBuf == NULL)
res = SZ_ERROR_MEM;
}
@ -1709,14 +1716,14 @@ 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* dest)
{
size_t offs = p->FileNameOffsets[fileIndex];
size_t len = p->FileNameOffsets[fileIndex + 1] - offs;
if (dest != 0)
{
size_t i;
const Byte *src = p->FileNames + offs * 2;
const Byte* src = p->FileNames + offs * 2;
for (i = 0; i < len; i++)
dest[i] = GetUi16(src + i * 2);
}

8
SevenZip/7zBuf.c
View file

@ -5,13 +5,13 @@
#include "7zBuf.h"
void Buf_Init(CBuf *p)
void Buf_Init(CBuf* p)
{
p->data = 0;
p->size = 0;
}
int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc)
int Buf_Create(CBuf* p, size_t size, ISzAlloc* alloc)
{
p->size = 0;
if (size == 0)
@ -19,7 +19,7 @@ int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc)
p->data = 0;
return 1;
}
p->data = (Byte *)alloc->Alloc(alloc, size);
p->data = (Byte*)alloc->Alloc(alloc, size);
if (p->data != 0)
{
p->size = size;
@ -28,7 +28,7 @@ int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc)
return 0;
}
void Buf_Free(CBuf *p, ISzAlloc *alloc)
void Buf_Free(CBuf* p, ISzAlloc* alloc)
{
alloc->Free(alloc, p->data);
p->data = 0;

18
SevenZip/7zBuf.h
View file

@ -10,25 +10,25 @@ EXTERN_C_BEGIN
typedef struct
{
Byte *data;
Byte* data;
size_t size;
} CBuf;
void Buf_Init(CBuf *p);
int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc);
void Buf_Free(CBuf *p, ISzAlloc *alloc);
void Buf_Init(CBuf* p);
int Buf_Create(CBuf* p, size_t size, ISzAlloc* alloc);
void Buf_Free(CBuf* p, ISzAlloc* alloc);
typedef struct
{
Byte *data;
Byte* data;
size_t size;
size_t pos;
} CDynBuf;
void DynBuf_Construct(CDynBuf *p);
void DynBuf_SeekToBeg(CDynBuf *p);
int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc);
void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc);
void DynBuf_Construct(CDynBuf* p);
void DynBuf_SeekToBeg(CDynBuf* p);
int DynBuf_Write(CDynBuf* p, const Byte* buf, size_t size, ISzAlloc* alloc);
void DynBuf_Free(CDynBuf* p, ISzAlloc* alloc);
EXTERN_C_END

50
SevenZip/7zCrc.c
View file

@ -9,7 +9,7 @@
#define kCrcPoly 0xEDB88320
#ifdef MY_CPU_LE
#define CRC_NUM_TABLES 8
#define CRC_NUM_TABLES 8
#else
#define CRC_NUM_TABLES 9
@ -20,11 +20,11 @@
#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 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void* data, size_t size, const UInt32* table);
UInt32 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void* data, size_t size, const UInt32* table);
#endif
typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void* data, size_t size, const UInt32* table);
CRC_FUNC g_CrcUpdateT4;
CRC_FUNC g_CrcUpdateT8;
@ -32,22 +32,22 @@ CRC_FUNC g_CrcUpdate;
UInt32 g_CrcTable[256 * CRC_NUM_TABLES];
UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)
UInt32 MY_FAST_CALL CrcUpdate(UInt32 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 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 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void* data, size_t size, const UInt32* table)
{
const Byte *p = (const Byte *)data;
const Byte *pEnd = p + size;
const Byte* p = (const Byte*)data;
const Byte* pEnd = p + size;
for (; p != pEnd; p++)
v = CRC_UPDATE_BYTE_2(v, *p);
return v;
@ -70,44 +70,44 @@ void MY_FAST_CALL CrcGenerateTable()
g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
}
#if CRC_NUM_TABLES < 4
#if CRC_NUM_TABLES < 4
g_CrcUpdate = CrcUpdateT1;
#else
#else
#ifdef MY_CPU_LE
#ifdef MY_CPU_LE
g_CrcUpdateT4 = CrcUpdateT4;
g_CrcUpdate = CrcUpdateT4;
#if CRC_NUM_TABLES >= 8
#if CRC_NUM_TABLES >= 8
g_CrcUpdateT8 = CrcUpdateT8;
#ifdef MY_CPU_X86_OR_AMD64
#ifdef MY_CPU_X86_OR_AMD64
if (!CPU_Is_InOrder())
g_CrcUpdate = CrcUpdateT8;
#endif
#endif
#endif
#endif
#else
#else
{
#ifndef MY_CPU_BE
#ifndef MY_CPU_BE
UInt32 k = 0x01020304;
const Byte *p = (const Byte *)&k;
if (p[0] == 4 && p[1] == 3)
{
g_CrcUpdateT4 = CrcUpdateT4;
g_CrcUpdate = CrcUpdateT4;
#if CRC_NUM_TABLES >= 8
#if CRC_NUM_TABLES >= 8
g_CrcUpdateT8 = CrcUpdateT8;
// g_CrcUpdate = CrcUpdateT8;
#endif
#endif
}
else if (p[0] != 1 || p[1] != 2)
g_CrcUpdate = CrcUpdateT1;
else
#endif
#endif
{
for (i = 256 * CRC_NUM_TABLES - 1; i >= 256; i--)
{
@ -116,13 +116,13 @@ void MY_FAST_CALL CrcGenerateTable()
}
g_CrcUpdateT4 = CrcUpdateT1_BeT4;
g_CrcUpdate = CrcUpdateT1_BeT4;
#if CRC_NUM_TABLES >= 8
#if CRC_NUM_TABLES >= 8
g_CrcUpdateT8 = CrcUpdateT1_BeT8;
// g_CrcUpdate = CrcUpdateT1_BeT8;
#endif
#endif
}
}
#endif
#endif
#endif
#endif
}

4
SevenZip/7zCrc.h
View file

@ -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 MY_FAST_CALL CrcUpdate(UInt32 crc, const void* data, size_t size);
UInt32 MY_FAST_CALL CrcCalc(const void* data, size_t size);
EXTERN_C_END

20
SevenZip/7zCrcOpt.c
View file

@ -9,16 +9,16 @@
#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 MY_FAST_CALL CrcUpdateT4(UInt32 v, const void* data, size_t size, const UInt32* table)
{
const Byte *p = (const Byte *)data;
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*)p;
v =
table[0x300 + ((v ) & 0xFF)]
table[0x300 + ((v) & 0xFF)]
^ table[0x200 + ((v >> 8) & 0xFF)]
^ table[0x100 + ((v >> 16) & 0xFF)]
^ table[0x000 + ((v >> 24))];
@ -28,23 +28,23 @@ 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 MY_FAST_CALL CrcUpdateT8(UInt32 v, const void* data, size_t size, const UInt32* table)
{
const Byte *p = (const Byte *)data;
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;
v ^= *(const UInt32*)p;
v =
table[0x700 + ((v ) & 0xFF)]
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*)p + 1);
v ^=
table[0x300 + ((d ) & 0xFF)]
table[0x300 + ((d) & 0xFF)]
^ table[0x200 + ((d >> 8) & 0xFF)]
^ table[0x100 + ((d >> 16) & 0xFF)]
^ table[0x000 + ((d >> 24))];

110
SevenZip/7zDec.c
View file

@ -131,8 +131,8 @@ static SRes SzDecodePpmd(const Byte *props, unsigned propsSize, UInt64 inSize, I
#endif
static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, ILookInStream *inStream,
Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)
static SRes SzDecodeLzma(const Byte* props, unsigned propsSize, UInt64 inSize, ILookInStream* inStream,
Byte* outBuffer, SizeT outSize, ISzAlloc* allocMain)
{
CLzmaDec state;
SRes res = SZ_OK;
@ -145,7 +145,7 @@ static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, I
for (;;)
{
const void *inBuf = NULL;
const void* inBuf = NULL;
size_t lookahead = (1 << 18);
if (lookahead > inSize)
lookahead = (size_t)inSize;
@ -178,7 +178,7 @@ static SRes SzDecodeLzma(const Byte *props, unsigned propsSize, UInt64 inSize, I
break;
}
res = inStream->Skip((void *)inStream, inProcessed);
res = inStream->Skip((void*)inStream, inProcessed);
if (res != SZ_OK)
break;
}
@ -191,8 +191,8 @@ 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,
Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)
static SRes SzDecodeLzma2(const Byte* props, unsigned propsSize, UInt64 inSize, ILookInStream* inStream,
Byte* outBuffer, SizeT outSize, ISzAlloc* allocMain)
{
CLzma2Dec state;
SRes res = SZ_OK;
@ -207,7 +207,7 @@ static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize,
for (;;)
{
const void *inBuf = NULL;
const void* inBuf = NULL;
size_t lookahead = (1 << 18);
if (lookahead > inSize)
lookahead = (size_t)inSize;
@ -237,7 +237,7 @@ static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize,
break;
}
res = inStream->Skip((void *)inStream, inProcessed);
res = inStream->Skip((void*)inStream, inProcessed);
if (res != SZ_OK)
break;
}
@ -250,11 +250,11 @@ static SRes SzDecodeLzma2(const Byte *props, unsigned propsSize, UInt64 inSize,
#endif
static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer)
static SRes SzDecodeCopy(UInt64 inSize, ILookInStream* inStream, Byte* outBuffer)
{
while (inSize > 0)
{
const void *inBuf;
const void* inBuf;
size_t curSize = (1 << 18);
if (curSize > inSize)
curSize = (size_t)inSize;
@ -275,18 +275,18 @@ static Bool IS_MAIN_METHOD(UInt32 m)
{
case k_Copy:
case k_LZMA:
#ifndef _7Z_NO_METHOD_LZMA2
#ifndef _7Z_NO_METHOD_LZMA2
case k_LZMA2:
#endif
#ifdef _7ZIP_PPMD_SUPPPORT
#endif
#ifdef _7ZIP_PPMD_SUPPPORT
case k_PPMD:
#endif
#endif
return True;
}
return False;
}
static Bool IS_SUPPORTED_CODER(const CSzCoderInfo *c)
static Bool IS_SUPPORTED_CODER(const CSzCoderInfo* c)
{
return
c->NumStreams == 1
@ -296,7 +296,7 @@ static Bool IS_SUPPORTED_CODER(const CSzCoderInfo *c)
#define IS_BCJ2(c) ((c)->MethodID == k_BCJ2 && (c)->NumStreams == 4)
static SRes CheckSupportedFolder(const CSzFolder *f)
static SRes CheckSupportedFolder(const CSzFolder* f)
{
if (f->NumCoders < 1 || f->NumCoders > 4)
return SZ_ERROR_UNSUPPORTED;
@ -310,11 +310,11 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
}
#ifndef _7Z_NO_METHODS_FILTERS
#ifndef _7Z_NO_METHODS_FILTERS
if (f->NumCoders == 2)
{
const CSzCoderInfo *c = &f->Coders[1];
const CSzCoderInfo* c = &f->Coders[1];
if (
/* c->MethodID > (UInt32)0xFFFFFFFF || */
c->NumStreams != 1
@ -340,7 +340,7 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
return SZ_OK;
}
#endif
#endif
if (f->NumCoders == 4)
@ -367,44 +367,44 @@ static SRes CheckSupportedFolder(const CSzFolder *f)
#define CASE_BRA_CONV(isa) case k_ ## isa: isa ## _Convert(outBuffer, outSize, 0, 0); break;
static SRes SzFolder_Decode2(const CSzFolder *folder,
const Byte *propsData,
const UInt64 *unpackSizes,
const UInt64 *packPositions,
ILookInStream *inStream, UInt64 startPos,
Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain,
Byte *tempBuf[])
static SRes SzFolder_Decode2(const CSzFolder* folder,
const Byte* propsData,
const UInt64* unpackSizes,
const UInt64* packPositions,
ILookInStream* inStream, UInt64 startPos,
Byte* outBuffer, SizeT outSize, ISzAlloc* allocMain,
Byte* tempBuf[])
{
UInt32 ci;
SizeT tempSizes[3] = { 0, 0, 0};
SizeT tempSizes[3] = {0, 0, 0};
SizeT tempSize3 = 0;
Byte *tempBuf3 = 0;
Byte* tempBuf3 = 0;
RINOK(CheckSupportedFolder(folder));
for (ci = 0; ci < folder->NumCoders; ci++)
{
const CSzCoderInfo *coder = &folder->Coders[ci];
const CSzCoderInfo* coder = &folder->Coders[ci];
if (IS_MAIN_METHOD((UInt32)coder->MethodID))
{
UInt32 si = 0;
UInt64 offset;
UInt64 inSize;
Byte *outBufCur = outBuffer;
Byte* outBufCur = outBuffer;
SizeT outSizeCur = outSize;
if (folder->NumCoders == 4)
{
UInt32 indices[] = { 3, 2, 0 };
UInt32 indices[] = {3, 2, 0};
UInt64 unpackSize = unpackSizes[ci];
si = indices[ci];
if (ci < 2)
{
Byte *temp;
Byte* temp;
outSizeCur = (SizeT)unpackSize;
if (outSizeCur != unpackSize)
return SZ_ERROR_MEM;
temp = (Byte *)IAlloc_Alloc(allocMain, outSizeCur);
temp = (Byte*)IAlloc_Alloc(allocMain, outSizeCur);
if (!temp && outSizeCur != 0)
return SZ_ERROR_MEM;
outBufCur = tempBuf[1 - ci] = temp;
@ -432,20 +432,22 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
}
else if (coder->MethodID == k_LZMA)
{
RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
RINOK(SzDecodeLzma(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur
, allocMain));
}
#ifndef _7Z_NO_METHOD_LZMA2
#ifndef _7Z_NO_METHOD_LZMA2
else if (coder->MethodID == k_LZMA2)
{
RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
RINOK(SzDecodeLzma2(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur,
outSizeCur, allocMain));
}
#endif
#ifdef _7ZIP_PPMD_SUPPPORT
#endif
#ifdef _7ZIP_PPMD_SUPPPORT
else if (coder->MethodID == k_PPMD)
{
RINOK(SzDecodePpmd(propsData + coder->PropsOffset, coder->PropsSize, inSize, inStream, outBufCur, outSizeCur, allocMain));
}
#endif
#endif
else
return SZ_ERROR_UNSUPPORTED;
}
@ -460,7 +462,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
tempSizes[2] = (SizeT)s3Size;
if (tempSizes[2] != s3Size)
return SZ_ERROR_MEM;
tempBuf[2] = (Byte *)IAlloc_Alloc(allocMain, tempSizes[2]);
tempBuf[2] = (Byte*)IAlloc_Alloc(allocMain, tempSizes[2]);
if (!tempBuf[2] && tempSizes[2] != 0)
return SZ_ERROR_MEM;
@ -475,10 +477,14 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
{
CBcj2Dec p;
p.bufs[0] = tempBuf3; p.lims[0] = tempBuf3 + tempSize3;
p.bufs[1] = tempBuf[0]; p.lims[1] = tempBuf[0] + tempSizes[0];
p.bufs[2] = tempBuf[1]; p.lims[2] = tempBuf[1] + tempSizes[1];
p.bufs[3] = tempBuf[2]; p.lims[3] = tempBuf[2] + tempSizes[2];
p.bufs[0] = tempBuf3;
p.lims[0] = tempBuf3 + tempSize3;
p.bufs[1] = tempBuf[0];
p.lims[1] = tempBuf[0] + tempSizes[0];
p.bufs[2] = tempBuf[1];
p.lims[2] = tempBuf[1] + tempSizes[1];
p.bufs[3] = tempBuf[2];
p.lims[3] = tempBuf[2] + tempSizes[2];
p.dest = outBuffer;
p.destLim = outBuffer + outSize;
@ -501,7 +507,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
}
}
}
#ifndef _7Z_NO_METHODS_FILTERS
#ifndef _7Z_NO_METHODS_FILTERS
else if (ci == 1)
{
if (coder->MethodID == k_Delta)
@ -537,7 +543,7 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
}
}
}
#endif
#endif
else
return SZ_ERROR_UNSUPPORTED;
}
@ -546,16 +552,16 @@ static SRes SzFolder_Decode2(const CSzFolder *folder,
}
SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
ILookInStream *inStream, UInt64 startPos,
Byte *outBuffer, size_t outSize,
ISzAlloc *allocMain)
SRes SzAr_DecodeFolder(const CSzAr* p, UInt32 folderIndex,
ILookInStream* inStream, UInt64 startPos,
Byte* outBuffer, size_t outSize,
ISzAlloc* allocMain)
{
SRes res;
CSzFolder folder;
CSzData sd;
const Byte *data = p->CodersData + p->FoCodersOffsets[folderIndex];
const Byte* data = p->CodersData + p->FoCodersOffsets[folderIndex];
sd.Data = data;
sd.Size = p->FoCodersOffsets[folderIndex + 1] - p->FoCodersOffsets[folderIndex];
@ -570,7 +576,7 @@ SRes SzAr_DecodeFolder(const CSzAr *p, UInt32 folderIndex,
return SZ_ERROR_FAIL;
{
unsigned i;
Byte *tempBuf[3] = { 0, 0, 0};
Byte* tempBuf[3] = {0, 0, 0};
res = SzFolder_Decode2(&folder, data,
&p->CoderUnpackSizes[p->FoToCoderUnpackSizes[folderIndex]],

108
SevenZip/7zFile.c
View file

@ -27,42 +27,42 @@
#endif
void File_Construct(CSzFile *p)
void File_Construct(CSzFile* p)
{
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
p->handle = INVALID_HANDLE_VALUE;
#else
#else
p->file = NULL;
#endif
#endif
}
#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
static WRes File_Open(CSzFile *p, const char *name, int writeMode)
static WRes File_Open(CSzFile* p, const char* name, int writeMode)
{
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
p->handle = CreateFileA(name,
writeMode ? GENERIC_WRITE : GENERIC_READ,
FILE_SHARE_READ, NULL,
writeMode ? CREATE_ALWAYS : OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
#else
#else
p->file = fopen(name, writeMode ? "wb+" : "rb");
return (p->file != 0) ? 0 :
#ifdef UNDER_CE
#ifdef UNDER_CE
2; /* ENOENT */
#else
#else
errno;
#endif
#endif
#endif
#endif
}
WRes InFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 0); }
WRes OutFile_Open(CSzFile *p, const char *name) { return File_Open(p, name, 1); }
WRes InFile_Open(CSzFile* p, const char* name) { return File_Open(p, name, 0); }
WRes OutFile_Open(CSzFile* p, const char* name) { return File_Open(p, name, 1); }
#endif
#ifdef USE_WINDOWS_FILE
static WRes File_OpenW(CSzFile *p, const WCHAR *name, int writeMode)
static WRes File_OpenW(CSzFile* p, const WCHAR* name, int writeMode)
{
p->handle = CreateFileW(name,
writeMode ? GENERIC_WRITE : GENERIC_READ,
@ -71,20 +71,21 @@ static WRes File_OpenW(CSzFile *p, const WCHAR *name, int writeMode)
FILE_ATTRIBUTE_NORMAL, NULL);
return (p->handle != INVALID_HANDLE_VALUE) ? 0 : GetLastError();
}
WRes InFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 0); }
WRes OutFile_OpenW(CSzFile *p, const WCHAR *name) { return File_OpenW(p, name, 1); }
WRes InFile_OpenW(CSzFile* p, const WCHAR* name) { return File_OpenW(p, name, 0); }
WRes OutFile_OpenW(CSzFile* p, const WCHAR* name) { return File_OpenW(p, name, 1); }
#endif
WRes File_Close(CSzFile *p)
WRes File_Close(CSzFile* p)
{
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
if (p->handle != INVALID_HANDLE_VALUE)
{
if (!CloseHandle(p->handle))
return GetLastError();
p->handle = INVALID_HANDLE_VALUE;
}
#else
#else
if (p->file != NULL)
{
int res = fclose(p->file);
@ -92,17 +93,17 @@ WRes File_Close(CSzFile *p)
return res;
p->file = NULL;
}
#endif
#endif
return 0;
}
WRes File_Read(CSzFile *p, void *data, size_t *size)
WRes File_Read(CSzFile* p, void* data, size_t* size)
{
size_t originalSize = *size;
if (originalSize == 0)
return 0;
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
*size = 0;
do
@ -110,7 +111,7 @@ WRes File_Read(CSzFile *p, void *data, size_t *size)
DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
DWORD processed = 0;
BOOL res = ReadFile(p->handle, data, curSize, &processed, NULL);
data = (void *)((Byte *)data + processed);
data = (void*)((Byte*)data + processed);
originalSize -= processed;
*size += processed;
if (!res)
@ -121,23 +122,23 @@ WRes File_Read(CSzFile *p, void *data, size_t *size)
while (originalSize > 0);
return 0;
#else
#else
*size = fread(data, 1, originalSize, p->file);
if (*size == originalSize)
return 0;
return ferror(p->file);
#endif
#endif
}
WRes File_Write(CSzFile *p, const void *data, size_t *size)
WRes File_Write(CSzFile* p, const void* data, size_t* size)
{
size_t originalSize = *size;
if (originalSize == 0)
return 0;
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
*size = 0;
do
@ -145,7 +146,7 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size)
DWORD curSize = (originalSize > kChunkSizeMax) ? kChunkSizeMax : (DWORD)originalSize;
DWORD processed = 0;
BOOL res = WriteFile(p->handle, data, curSize, &processed, NULL);
data = (void *)((Byte *)data + processed);
data = (void*)((Byte*)data + processed);
originalSize -= processed;
*size += processed;
if (!res)
@ -156,19 +157,19 @@ WRes File_Write(CSzFile *p, const void *data, size_t *size)
while (originalSize > 0);
return 0;
#else
#else
*size = fwrite(data, 1, originalSize, p->file);
if (*size == originalSize)
return 0;
return ferror(p->file);
#endif
#endif
}
WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
WRes File_Seek(CSzFile* p, Int64* pos, ESzSeek origin)
{
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
LARGE_INTEGER value;
DWORD moveMethod;
@ -176,9 +177,12 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
value.HighPart = (LONG)((UInt64)*pos >> 16 >> 16); /* for case when UInt64 is 32-bit only */
switch (origin)
{
case SZ_SEEK_SET: moveMethod = FILE_BEGIN; break;
case SZ_SEEK_CUR: moveMethod = FILE_CURRENT; break;
case SZ_SEEK_END: moveMethod = FILE_END; break;
case SZ_SEEK_SET: moveMethod = FILE_BEGIN;
break;
case SZ_SEEK_CUR: moveMethod = FILE_CURRENT;
break;
case SZ_SEEK_END: moveMethod = FILE_END;
break;
default: return ERROR_INVALID_PARAMETER;
}
value.LowPart = SetFilePointer(p->handle, value.LowPart, &value.HighPart, moveMethod);
@ -191,7 +195,7 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
*pos = ((Int64)value.HighPart << 32) | value.LowPart;
return 0;
#else
#else
int moveMethod;
int res;
@ -206,12 +210,12 @@ WRes File_Seek(CSzFile *p, Int64 *pos, ESzSeek origin)
*pos = ftell(p->file);
return res;
#endif
#endif
}
WRes File_GetLength(CSzFile *p, UInt64 *length)
WRes File_GetLength(CSzFile* p, UInt64* length)
{
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
DWORD sizeHigh;
DWORD sizeLow = GetFileSize(p->handle, &sizeHigh);
@ -224,7 +228,7 @@ WRes File_GetLength(CSzFile *p, UInt64 *length)
*length = (((UInt64)sizeHigh) << 32) + sizeLow;
return 0;
#else
#else
long pos = ftell(p->file);
int res = fseek(p->file, 0, SEEK_END);
@ -232,19 +236,19 @@ WRes File_GetLength(CSzFile *p, UInt64 *length)
fseek(p->file, pos, SEEK_SET);
return res;
#endif
#endif
}
/* ---------- FileSeqInStream ---------- */
static SRes FileSeqInStream_Read(void *pp, void *buf, size_t *size)
static SRes FileSeqInStream_Read(void* pp, void* buf, size_t* size)
{
CFileSeqInStream *p = (CFileSeqInStream *)pp;
CFileSeqInStream* p = (CFileSeqInStream*)pp;
return File_Read(&p->file, buf, size) == 0 ? SZ_OK : SZ_ERROR_READ;
}
void FileSeqInStream_CreateVTable(CFileSeqInStream *p)
void FileSeqInStream_CreateVTable(CFileSeqInStream* p)
{
p->s.Read = FileSeqInStream_Read;
}
@ -252,19 +256,19 @@ void FileSeqInStream_CreateVTable(CFileSeqInStream *p)
/* ---------- FileInStream ---------- */
static SRes FileInStream_Read(void *pp, void *buf, size_t *size)
static SRes FileInStream_Read(void* pp, void* buf, size_t* size)
{
CFileInStream *p = (CFileInStream *)pp;
CFileInStream* p = (CFileInStream*)pp;
return (File_Read(&p->file, buf, size) == 0) ? SZ_OK : SZ_ERROR_READ;
}
static SRes FileInStream_Seek(void *pp, Int64 *pos, ESzSeek origin)
static SRes FileInStream_Seek(void* pp, Int64* pos, ESzSeek origin)
{
CFileInStream *p = (CFileInStream *)pp;
CFileInStream* p = (CFileInStream*)pp;
return File_Seek(&p->file, pos, origin);
}
void FileInStream_CreateVTable(CFileInStream *p)
void FileInStream_CreateVTable(CFileInStream* p)
{
p->s.Read = FileInStream_Read;
p->s.Seek = FileInStream_Seek;
@ -273,14 +277,14 @@ void FileInStream_CreateVTable(CFileInStream *p)
/* ---------- FileOutStream ---------- */
static size_t FileOutStream_Write(void *pp, const void *data, size_t size)
static size_t FileOutStream_Write(void* pp, const void* data, size_t size)
{
CFileOutStream *p = (CFileOutStream *)pp;
CFileOutStream* p = (CFileOutStream*)pp;
File_Write(&p->file, data, &size);
return size;
}
void FileOutStream_CreateVTable(CFileOutStream *p)
void FileOutStream_CreateVTable(CFileOutStream* p)
{
p->s.Write = FileOutStream_Write;
}

32
SevenZip/7zFile.h
View file

@ -22,32 +22,32 @@ EXTERN_C_BEGIN
typedef struct
{
#ifdef USE_WINDOWS_FILE
#ifdef USE_WINDOWS_FILE
HANDLE handle;
#else
#else
FILE *file;
#endif
#endif
} CSzFile;
void File_Construct(CSzFile *p);
void File_Construct(CSzFile* p);
#if !defined(UNDER_CE) || !defined(USE_WINDOWS_FILE)
WRes InFile_Open(CSzFile *p, const char *name);
WRes OutFile_Open(CSzFile *p, const char *name);
WRes InFile_Open(CSzFile* p, const char* name);
WRes OutFile_Open(CSzFile* p, const char* name);
#endif
#ifdef USE_WINDOWS_FILE
WRes InFile_OpenW(CSzFile *p, const WCHAR *name);
WRes OutFile_OpenW(CSzFile *p, const WCHAR *name);
WRes InFile_OpenW(CSzFile* p, const WCHAR* name);
WRes OutFile_OpenW(CSzFile* p, const WCHAR* name);
#endif
WRes File_Close(CSzFile *p);
WRes File_Close(CSzFile* p);
/* reads max(*size, remain file's size) bytes */
WRes File_Read(CSzFile *p, void *data, size_t *size);
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_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* pos, ESzSeek origin);
WRes File_GetLength(CSzFile* p, UInt64* length);
/* ---------- FileInStream ---------- */
@ -58,7 +58,7 @@ typedef struct
CSzFile file;
} CFileSeqInStream;
void FileSeqInStream_CreateVTable(CFileSeqInStream *p);
void FileSeqInStream_CreateVTable(CFileSeqInStream* p);
typedef struct
@ -67,7 +67,7 @@ typedef struct
CSzFile file;
} CFileInStream;
void FileInStream_CreateVTable(CFileInStream *p);
void FileInStream_CreateVTable(CFileInStream* p);
typedef struct
@ -76,7 +76,7 @@ typedef struct
CSzFile file;
} CFileOutStream;
void FileOutStream_CreateVTable(CFileOutStream *p);
void FileOutStream_CreateVTable(CFileOutStream* p);
EXTERN_C_END

28
SevenZip/7zMemBuffer.c
View file

@ -2,10 +2,10 @@
#include "7zMemBuffer.h"
#include <memory.h>
WRes MemBuffer_Read(CSzMemBuffer *p, void *data, size_t *size)
WRes MemBuffer_Read(CSzMemBuffer* p, void* data, size_t* size)
{
size_t originalSize = *size;
if(originalSize == 0)
if (originalSize == 0)
return 0;
size_t length = (size_t)(p->pos + (Int64)(*size) > p->size ? p->size - p->pos - 1 : *size);
@ -14,31 +14,35 @@ WRes MemBuffer_Read(CSzMemBuffer *p, void *data, size_t *size)
return 0;
}
WRes MemBuffer_Seek(CSzMemBuffer *p, Int64 *pos, ESzSeek origin)
WRes MemBuffer_Seek(CSzMemBuffer* p, Int64* pos, ESzSeek origin)
{
switch(origin) {
case SZ_SEEK_SET: p->pos = 0 + *pos; break;
case SZ_SEEK_CUR: p->pos += *pos; break;
case SZ_SEEK_END: p->pos = p->size - *pos; break;
switch (origin)
{
case SZ_SEEK_SET: p->pos = 0 + *pos;
break;
case SZ_SEEK_CUR: p->pos += *pos;
break;
case SZ_SEEK_END: p->pos = p->size - *pos;
break;
default: return 1;
}
*pos = p->pos;
return 0;
}
static SRes MemBufferInStream_Read(void *pp, void *buf, size_t *size)
static SRes MemBufferInStream_Read(void* pp, void* buf, size_t* size)
{
CMemBufferInStream *p = (CMemBufferInStream *)pp;
CMemBufferInStream* p = (CMemBufferInStream*)pp;
return (MemBuffer_Read(&p->buffer, buf, size) == 0) ? SZ_OK : SZ_ERROR_READ;
}
static SRes MemBufferInStream_Seek(void *pp, Int64 *pos, ESzSeek origin)
static SRes MemBufferInStream_Seek(void* pp, Int64* pos, ESzSeek origin)
{
CMemBufferInStream *p = (CMemBufferInStream *)pp;
CMemBufferInStream* p = (CMemBufferInStream*)pp;
return MemBuffer_Seek(&p->buffer, pos, origin);
}
void MemBufferInit(CMemBufferInStream *memBuferStream, CLookToRead *lookStream, void* buffer, size_t size)
void MemBufferInit(CMemBufferInStream* memBuferStream, CLookToRead* lookStream, void* buffer, size_t size)
{
memBuferStream->buffer.buffer = buffer;
memBuferStream->buffer.pos = 0;

6
SevenZip/7zMemBuffer.h
View file

@ -14,8 +14,8 @@ typedef struct
} CSzMemBuffer;
/* reads max(*size, remain file's size) bytes */
WRes MemBuffer_Read(CSzMemBuffer *p, void *data, size_t *size);
WRes MemBuffer_Seek(CSzMemBuffer *p, Int64 *pos, ESzSeek origin);
WRes MemBuffer_Read(CSzMemBuffer* p, void* data, size_t* size);
WRes MemBuffer_Seek(CSzMemBuffer* p, Int64* pos, ESzSeek origin);
/* ---------- FileInStream ---------- */
typedef struct
@ -24,6 +24,6 @@ typedef struct
CSzMemBuffer buffer;
} CMemBufferInStream;
void MemBufferInit(CMemBufferInStream *memBuferStream, CLookToRead *lookStream, void* buffer, size_t size);
void MemBufferInit(CMemBufferInStream* memBuferStream, CLookToRead* lookStream, void* buffer, size_t size);
EXTERN_C_END

60
SevenZip/7zStream.c
View file

@ -7,7 +7,7 @@
#include "7zTypes.h"
SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType)
SRes SeqInStream_Read2(ISeqInStream* stream, void* buf, size_t size, SRes errorType)
{
while (size != 0)
{
@ -15,33 +15,33 @@ SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorT
RINOK(stream->Read(stream, buf, &processed));
if (processed == 0)
return errorType;
buf = (void *)((Byte *)buf + processed);
buf = (void*)((Byte*)buf + processed);
size -= processed;
}
return SZ_OK;
}
SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size)
SRes SeqInStream_Read(ISeqInStream* stream, void* buf, size_t size)
{
return SeqInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
}
SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf)
SRes SeqInStream_ReadByte(ISeqInStream* stream, Byte* buf)
{
size_t processed = 1;
RINOK(stream->Read(stream, buf, &processed));
return (processed == 1) ? SZ_OK : SZ_ERROR_INPUT_EOF;
}
SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset)
SRes LookInStream_SeekTo(ILookInStream* stream, UInt64 offset)
{
Int64 t = offset;
return stream->Seek(stream, &t, SZ_SEEK_SET);
}
SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size)
SRes LookInStream_LookRead(ILookInStream* stream, void* buf, size_t* size)
{
const void *lookBuf;
const void* lookBuf;
if (*size == 0)
return SZ_OK;
RINOK(stream->Look(stream, &lookBuf, size));
@ -49,7 +49,7 @@ SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size)
return stream->Skip(stream, *size);
}
SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType)
SRes LookInStream_Read2(ILookInStream* stream, void* buf, size_t size, SRes errorType)
{
while (size != 0)
{
@ -57,21 +57,21 @@ SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes erro
RINOK(stream->Read(stream, buf, &processed));
if (processed == 0)
return errorType;
buf = (void *)((Byte *)buf + processed);
buf = (void*)((Byte*)buf + processed);
size -= processed;
}
return SZ_OK;
}
SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size)
SRes LookInStream_Read(ILookInStream* stream, void* buf, size_t size)
{
return LookInStream_Read2(stream, buf, size, SZ_ERROR_INPUT_EOF);
}
static SRes LookToRead_Look_Lookahead(void *pp, const void **buf, size_t *size)
static SRes LookToRead_Look_Lookahead(void* pp, const void** buf, size_t* size)
{
SRes res = SZ_OK;
CLookToRead *p = (CLookToRead *)pp;
CLookToRead* p = (CLookToRead*)pp;
size_t size2 = p->size - p->pos;
if (size2 == 0 && *size > 0)
{
@ -86,10 +86,10 @@ static SRes LookToRead_Look_Lookahead(void *pp, const void **buf, size_t *size)
return res;
}
static SRes LookToRead_Look_Exact(void *pp, const void **buf, size_t *size)
static SRes LookToRead_Look_Exact(void* pp, const void** buf, size_t* size)
{
SRes res = SZ_OK;
CLookToRead *p = (CLookToRead *)pp;
CLookToRead* p = (CLookToRead*)pp;
size_t size2 = p->size - p->pos;
if (size2 == 0 && *size > 0)
{
@ -105,16 +105,16 @@ static SRes LookToRead_Look_Exact(void *pp, const void **buf, size_t *size)
return res;
}
static SRes LookToRead_Skip(void *pp, size_t offset)
static SRes LookToRead_Skip(void* pp, size_t offset)
{
CLookToRead *p = (CLookToRead *)pp;
CLookToRead* p = (CLookToRead*)pp;
p->pos += offset;
return SZ_OK;
}
static SRes LookToRead_Read(void *pp, void *buf, size_t *size)
static SRes LookToRead_Read(void* pp, void* buf, size_t* size)
{
CLookToRead *p = (CLookToRead *)pp;
CLookToRead* p = (CLookToRead*)pp;
size_t rem = p->size - p->pos;
if (rem == 0)
return p->realStream->Read(p->realStream, buf, size);
@ -126,46 +126,44 @@ static SRes LookToRead_Read(void *pp, void *buf, size_t *size)
return SZ_OK;
}
static SRes LookToRead_Seek(void *pp, Int64 *pos, ESzSeek origin)
static SRes LookToRead_Seek(void* pp, Int64* pos, ESzSeek origin)
{
CLookToRead *p = (CLookToRead *)pp;
CLookToRead* p = (CLookToRead*)pp;
p->pos = p->size = 0;
return p->realStream->Seek(p->realStream, pos, origin);
}
void LookToRead_CreateVTable(CLookToRead *p, int lookahead)
void LookToRead_CreateVTable(CLookToRead* p, int lookahead)
{
p->s.Look = lookahead ?
LookToRead_Look_Lookahead :
LookToRead_Look_Exact;
p->s.Look = lookahead ? LookToRead_Look_Lookahead : LookToRead_Look_Exact;
p->s.Skip = LookToRead_Skip;
p->s.Read = LookToRead_Read;
p->s.Seek = LookToRead_Seek;
}
void LookToRead_Init(CLookToRead *p)
void LookToRead_Init(CLookToRead* p)
{
p->pos = p->size = 0;
}
static SRes SecToLook_Read(void *pp, void *buf, size_t *size)
static SRes SecToLook_Read(void* pp, void* buf, size_t* size)
{
CSecToLook *p = (CSecToLook *)pp;
CSecToLook* p = (CSecToLook*)pp;
return LookInStream_LookRead(p->realStream, buf, size);
}
void SecToLook_CreateVTable(CSecToLook *p)
void SecToLook_CreateVTable(CSecToLook* p)
{
p->s.Read = SecToLook_Read;
}
static SRes SecToRead_Read(void *pp, void *buf, size_t *size)
static SRes SecToRead_Read(void* pp, void* buf, size_t* size)
{
CSecToRead *p = (CSecToRead *)pp;
CSecToRead* p = (CSecToRead*)pp;
return p->realStream->Read(p->realStream, buf, size);
}
void SecToRead_CreateVTable(CSecToRead *p)
void SecToRead_CreateVTable(CSecToRead* p)
{
p->s.Read = SecToRead_Read;
}

54
SevenZip/7zTypes.h
View file

@ -128,29 +128,29 @@ typedef int Bool;
typedef struct
{
Byte (*Read)(void *p); /* reads one byte, returns 0 in case of EOF or error */
Byte (*Read)(void* p); /* reads one byte, returns 0 in case of EOF or error */
} IByteIn;
typedef struct
{
void (*Write)(void *p, Byte b);
void (*Write)(void* p, Byte b);
} IByteOut;
typedef struct
{
SRes (*Read)(void *p, void *buf, size_t *size);
SRes (*Read)(void* p, void* buf, size_t* size);
/* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
(output(*size) < input(*size)) is allowed */
} ISeqInStream;
/* it can return SZ_ERROR_INPUT_EOF */
SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size);
SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType);
SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf);
SRes SeqInStream_Read(ISeqInStream* stream, void* buf, size_t size);
SRes SeqInStream_Read2(ISeqInStream* stream, void* buf, size_t size, SRes errorType);
SRes SeqInStream_ReadByte(ISeqInStream* stream, Byte* buf);
typedef struct
{
size_t (*Write)(void *p, const void *buf, size_t size);
size_t (*Write)(void* p, const void* buf, size_t size);
/* Returns: result - the number of actually written bytes.
(result < size) means error */
} ISeqOutStream;
@ -164,72 +164,72 @@ typedef enum
typedef struct
{
SRes (*Read)(void *p, void *buf, size_t *size); /* same as ISeqInStream::Read */
SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
SRes (*Read)(void* p, void* buf, size_t* size); /* same as ISeqInStream::Read */
SRes (*Seek)(void* p, Int64* pos, ESzSeek origin);
} ISeekInStream;
typedef struct
{
SRes (*Look)(void *p, const void **buf, size_t *size);
SRes (*Look)(void* p, const void** buf, size_t* size);
/* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
(output(*size) > input(*size)) is not allowed
(output(*size) < input(*size)) is allowed */
SRes (*Skip)(void *p, size_t offset);
SRes (*Skip)(void* p, size_t offset);
/* offset must be <= output(*size) of Look */
SRes (*Read)(void *p, void *buf, size_t *size);
SRes (*Read)(void* p, void* buf, size_t* size);
/* reads directly (without buffer). It's same as ISeqInStream::Read */
SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
SRes (*Seek)(void* p, Int64* pos, ESzSeek origin);
} ILookInStream;
SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size);
SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset);
SRes LookInStream_LookRead(ILookInStream* stream, void* buf, size_t* size);
SRes LookInStream_SeekTo(ILookInStream* stream, UInt64 offset);
/* reads via ILookInStream::Read */
SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType);
SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size);
SRes LookInStream_Read2(ILookInStream* stream, void* buf, size_t size, SRes errorType);
SRes LookInStream_Read(ILookInStream* stream, void* buf, size_t size);
#define LookToRead_BUF_SIZE (1 << 14)
typedef struct
{
ILookInStream s;
ISeekInStream *realStream;
ISeekInStream* realStream;
size_t pos;
size_t size;
Byte buf[LookToRead_BUF_SIZE];
} CLookToRead;
void LookToRead_CreateVTable(CLookToRead *p, int lookahead);
void LookToRead_Init(CLookToRead *p);
void LookToRead_CreateVTable(CLookToRead* p, int lookahead);
void LookToRead_Init(CLookToRead* p);
typedef struct
{
ISeqInStream s;
ILookInStream *realStream;
ILookInStream* realStream;
} CSecToLook;
void SecToLook_CreateVTable(CSecToLook *p);
void SecToLook_CreateVTable(CSecToLook* p);
typedef struct
{
ISeqInStream s;
ILookInStream *realStream;
ILookInStream* realStream;
} CSecToRead;
void SecToRead_CreateVTable(CSecToRead *p);
void SecToRead_CreateVTable(CSecToRead* p);
typedef struct
{
SRes (*Progress)(void *p, UInt64 inSize, UInt64 outSize);
SRes (*Progress)(void* p, UInt64 inSize, UInt64 outSize);
/* Returns: result. (result != SZ_OK) means break.
Value (UInt64)(Int64)-1 for size means unknown value. */
} ICompressProgress;
typedef struct
{
void *(*Alloc)(void *p, size_t size);
void (*Free)(void *p, void *address); /* address can be 0 */
void*(*Alloc)(void* p, size_t size);
void (*Free)(void* p, void* address); /* address can be 0 */
} ISzAlloc;
#define IAlloc_Alloc(p, size) (p)->Alloc((p), size)

28
SevenZip/Bcj2.c
View file

@ -17,7 +17,7 @@
#define _UPDATE_0 p->range = bound; *prob = (CProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));
#define _UPDATE_1 p->range -= bound; p->code -= bound; *prob = (CProb)(ttt - (ttt >> kNumMoveBits));
void Bcj2Dec_Init(CBcj2Dec *p)
void Bcj2Dec_Init(CBcj2Dec* p)
{
unsigned i;
@ -30,7 +30,7 @@ void Bcj2Dec_Init(CBcj2Dec *p)
p->probs[i] = kBitModelTotal >> 1;
}
SRes Bcj2Dec_Decode(CBcj2Dec *p)
SRes Bcj2Dec_Decode(CBcj2Dec* p)
{
if (p->range <= 5)
{
@ -58,7 +58,7 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
{
while (p->state <= BCJ2_DEC_STATE_ORIG_3)
{
Byte *dest = p->dest;
Byte* dest = p->dest;
if (dest == p->destLim)
return SZ_OK;
*dest = p->temp[p->state++ - BCJ2_DEC_STATE_ORIG_0];
@ -119,9 +119,9 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
}
{
const Byte *src = p->bufs[BCJ2_STREAM_MAIN];
const Byte *srcLim;
Byte *dest;
const Byte* src = p->bufs[BCJ2_STREAM_MAIN];
const Byte* srcLim;
Byte* dest;
SizeT num = p->lims[BCJ2_STREAM_MAIN] - src;
if (num == 0)
@ -145,7 +145,8 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
if (p->temp[3] == 0x0F && (src[0] & 0xF0) == 0x80)
*dest = src[0];
else for (;;)
else
for (;;)
{
Byte b = *src;
*dest = b;
@ -177,15 +178,15 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
p->dest += num;
p->state =
p->bufs[BCJ2_STREAM_MAIN] ==
p->lims[BCJ2_STREAM_MAIN] ?
(unsigned)BCJ2_STREAM_MAIN :
(unsigned)BCJ2_DEC_STATE_ORIG;
p->lims[BCJ2_STREAM_MAIN]
? (unsigned)BCJ2_STREAM_MAIN
: (unsigned)BCJ2_DEC_STATE_ORIG;
return SZ_OK;
}
{
UInt32 bound, ttt;
CProb *prob;
CProb* prob;
Byte b = src[0];
Byte prev = (Byte)(num == 0 ? p->temp[3] : src[-1]);
@ -203,7 +204,6 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
continue;
}
_UPDATE_1
}
}
}
@ -211,8 +211,8 @@ SRes Bcj2Dec_Decode(CBcj2Dec *p)
{
UInt32 val;
unsigned cj = (p->temp[3] == 0xE8) ? BCJ2_STREAM_CALL : BCJ2_STREAM_JUMP;
const Byte *cur = p->bufs[cj];
Byte *dest;
const Byte* cur = p->bufs[cj];
Byte* dest;
SizeT rem;
if (cur == p->lims[cj])

25
SevenZip/Bcj2.h
View file

@ -61,10 +61,10 @@ dest is allowed to overlap with bufs[BCJ2_STREAM_MAIN], with the following condi
typedef struct
{
const Byte *bufs[BCJ2_NUM_STREAMS];
const Byte *lims[BCJ2_NUM_STREAMS];
Byte *dest;
const Byte *destLim;
const Byte* bufs[BCJ2_NUM_STREAMS];
const Byte* lims[BCJ2_NUM_STREAMS];
Byte* dest;
const Byte* destLim;
unsigned state; /* BCJ2_STREAM_MAIN has more priority than BCJ2_STATE_ORIG */
@ -75,15 +75,14 @@ typedef struct
UInt16 probs[2 + 256];
} CBcj2Dec;
void Bcj2Dec_Init(CBcj2Dec *p);
void Bcj2Dec_Init(CBcj2Dec* p);
/* Returns: SZ_OK or SZ_ERROR_DATA */
SRes Bcj2Dec_Decode(CBcj2Dec *p);
SRes Bcj2Dec_Decode(CBcj2Dec* p);
#define Bcj2Dec_IsFinished(_p_) ((_p_)->code == 0)
typedef enum
{
BCJ2_ENC_FINISH_MODE_CONTINUE,
@ -93,10 +92,10 @@ typedef enum
typedef struct
{
Byte *bufs[BCJ2_NUM_STREAMS];
const Byte *lims[BCJ2_NUM_STREAMS];
const Byte *src;
const Byte *srcLim;
Byte* bufs[BCJ2_NUM_STREAMS];
const Byte* lims[BCJ2_NUM_STREAMS];
const Byte* src;
const Byte* srcLim;
unsigned state;
EBcj2Enc_FinishMode finishMode;
@ -128,8 +127,8 @@ typedef struct
UInt16 probs[2 + 256];
} CBcj2Enc;
void Bcj2Enc_Init(CBcj2Enc *p);
void Bcj2Enc_Encode(CBcj2Enc *p);
void Bcj2Enc_Init(CBcj2Enc* p);
void Bcj2Enc_Encode(CBcj2Enc* p);
#define Bcj2Enc_Get_InputData_Size(p) ((SizeT)((p)->srcLim - (p)->src) + (p)->tempPos)
#define Bcj2Enc_IsFinished(p) ((p)->flushPos == 5)

8
SevenZip/Bra.c
View file

@ -5,7 +5,7 @@
#include "Bra.h"
SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT ARM_Convert(Byte* data, SizeT size, UInt32 ip, int encoding)
{
SizeT i;
if (size < 4)
@ -32,7 +32,7 @@ SizeT ARM_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
return i;
}
SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT ARMT_Convert(Byte* data, SizeT size, UInt32 ip, int encoding)
{
SizeT i;
if (size < 4)
@ -68,7 +68,7 @@ SizeT ARMT_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
return i;
}
SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT PPC_Convert(Byte* data, SizeT size, UInt32 ip, int encoding)
{
SizeT i;
if (size < 4)
@ -98,7 +98,7 @@ SizeT PPC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
return i;
}
SizeT SPARC_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT SPARC_Convert(Byte* data, SizeT size, UInt32 ip, int encoding)
{
UInt32 i;
if (size < 4)

12
SevenZip/Bra.h
View file

@ -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 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);
EXTERN_C_END

6
SevenZip/Bra86.c
View file

@ -7,7 +7,7 @@
#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 ip, UInt32* state, int encoding)
{
SizeT pos = 0;
UInt32 mask = *state & 7;
@ -18,8 +18,8 @@ SizeT x86_Convert(Byte *data, SizeT size, UInt32 ip, UInt32 *state, int encoding
for (;;)
{
Byte *p = data + pos;
const Byte *limit = data + size;
Byte* p = data + pos;
const Byte* limit = data + size;
for (; p < limit; p++)
if ((*p & 0xFE) == 0xE8)
break;

2
SevenZip/BraIA64.c
View file

@ -13,7 +13,7 @@ static const Byte kBranchTable[32] =
4, 4, 0, 0, 4, 4, 0, 0
};
SizeT IA64_Convert(Byte *data, SizeT size, UInt32 ip, int encoding)
SizeT IA64_Convert(Byte* data, SizeT size, UInt32 ip, int encoding)
{
SizeT i;
if (size < 16)

12
SevenZip/Compiler.h
View file

@ -6,23 +6,23 @@
#ifdef _MSC_VER
#ifdef UNDER_CE
#ifdef UNDER_CE
#define RPC_NO_WINDOWS_H
/* #pragma warning(disable : 4115) // '_RPC_ASYNC_STATE' : named type definition in parentheses */
#pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union
#pragma warning(disable : 4214) // nonstandard extension used : bit field types other than int
#endif
#endif
#if _MSC_VER >= 1300
#pragma warning(disable : 4996) // This function or variable may be unsafe
#else
#if _MSC_VER >= 1300
#pragma warning(disable : 4996) // This function or variable may be unsafe
#else
#pragma warning(disable : 4511) // copy constructor could not be generated
#pragma warning(disable : 4512) // assignment operator could not be generated
#pragma warning(disable : 4514) // unreferenced inline function has been removed
#pragma warning(disable : 4702) // unreachable code
#pragma warning(disable : 4710) // not inlined
#pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information
#endif
#endif
#endif

40
SevenZip/CpuArch.c
View file

@ -18,7 +18,7 @@
#if defined(USE_ASM) && !defined(MY_CPU_AMD64)
static UInt32 CheckFlag(UInt32 flag)
{
#ifdef _MSC_VER
#ifdef _MSC_VER
__asm pushfd;
__asm pop EAX;
__asm mov EDX, EAX;
@ -31,7 +31,7 @@ static UInt32 CheckFlag(UInt32 flag)
__asm push EDX;
__asm popfd;
__asm and flag, EAX;
#else
#else
__asm__ __volatile__ (
"pushf\n\t"
"pop %%EAX\n\t"
@ -47,7 +47,7 @@ static UInt32 CheckFlag(UInt32 flag)
"andl %%EAX, %0\n\t":
"=c" (flag) : "c" (flag) :
"%eax", "%edx");
#endif
#endif
return flag;
}
#define CHECK_CPUID_IS_SUPPORTED if (CheckFlag(1 << 18) == 0 || CheckFlag(1 << 21) == 0) return False;
@ -55,11 +55,11 @@ 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 function, UInt32* a, UInt32* b, UInt32* c, UInt32* d)
{
#ifdef USE_ASM
#ifdef USE_ASM
#ifdef _MSC_VER
#ifdef _MSC_VER
UInt32 a2, b2, c2, d2;
__asm xor EBX, EBX;
@ -77,33 +77,33 @@ void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)
*c = c2;
*d = d2;
#else
#else
__asm__ __volatile__ (
#if defined(MY_CPU_AMD64) && defined(__PIC__)
#if defined(MY_CPU_AMD64) && defined(__PIC__)
"mov %%rbx, %%rdi;"
"cpuid;"
"xchg %%rbx, %%rdi;"
: "=a" (*a) ,
"=D" (*b) ,
#elif defined(MY_CPU_X86) && defined(__PIC__)
#elif defined(MY_CPU_X86) && defined(__PIC__)
"mov %%ebx, %%edi;"
"cpuid;"
"xchgl %%ebx, %%edi;"
: "=a" (*a) ,
"=D" (*b) ,
#else
#else
"cpuid"
: "=a" (*a) ,
"=b" (*b) ,
#endif
#endif
"=c" (*c) ,
"=d" (*d)
: "0" (function)) ;
#endif
#endif
#else
#else
int CPUInfo[4];
__cpuid(CPUInfo, function);
@ -112,10 +112,10 @@ void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d)
*c = CPUInfo[2];
*d = CPUInfo[3];
#endif
#endif
}
Bool x86cpuid_CheckAndRead(Cx86cpuid *p)
Bool x86cpuid_CheckAndRead(Cx86cpuid* p)
{
CHECK_CPUID_IS_SUPPORTED
MyCPUID(0, &p->maxFunc, &p->vendor[0], &p->vendor[2], &p->vendor[1]);
@ -125,17 +125,17 @@ Bool x86cpuid_CheckAndRead(Cx86cpuid *p)
static const UInt32 kVendors[][3] =
{
{ 0x756E6547, 0x49656E69, 0x6C65746E},
{ 0x68747541, 0x69746E65, 0x444D4163},
{ 0x746E6543, 0x48727561, 0x736C7561}
{0x756E6547, 0x49656E69, 0x6C65746E},
{0x68747541, 0x69746E65, 0x444D4163},
{0x746E6543, 0x48727561, 0x736C7561}
};
int x86cpuid_GetFirm(const Cx86cpuid *p)
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* v = kVendors[i];
if (v[0] == p->vendor[0] &&
v[1] == p->vendor[1] &&
v[2] == p->vendor[2])

19
SevenZip/CpuArch.h
View file

@ -21,14 +21,14 @@ MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned mem
|| defined(__x86_64__) \
|| defined(__AMD64__) \
|| defined(__amd64__)
#define MY_CPU_AMD64
#define MY_CPU_AMD64
#endif
#if defined(MY_CPU_AMD64) \
|| defined(_M_IA64) \
|| defined(__AARCH64EL__) \
|| defined(__AARCH64EB__)
#define MY_CPU_64BIT
#define MY_CPU_64BIT
#endif
#if defined(_M_IX86) || defined(__i386__)
@ -67,7 +67,7 @@ MY_CPU_LE_UNALIGN means that CPU is LITTLE ENDIAN and CPU supports unaligned mem
|| defined(__MIPSEL) \
|| defined(_MIPSEL) \
|| (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__))
#define MY_CPU_LE
#define MY_CPU_LE
#endif
#if defined(__BIG_ENDIAN__) \
@ -91,10 +91,10 @@ Stop_Compiling_Bad_Endian
#ifdef MY_CPU_LE
#if defined(MY_CPU_X86_OR_AMD64) \
#if defined(MY_CPU_X86_OR_AMD64) \
/* || defined(__AARCH64EL__) */
#define MY_CPU_LE_UNALIGN
#endif
#define MY_CPU_LE_UNALIGN
#endif
#endif
@ -183,7 +183,6 @@ Stop_Compiling_Bad_Endian
((const Byte *)(p))[1] ))
#ifdef MY_CPU_X86_OR_AMD64
typedef struct
@ -203,10 +202,10 @@ enum
CPU_FIRM_VIA
};
void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d);
void MyCPUID(UInt32 function, UInt32* a, UInt32* b, UInt32* c, UInt32* d);
Bool x86cpuid_CheckAndRead(Cx86cpuid *p);
int x86cpuid_GetFirm(const Cx86cpuid *p);
Bool x86cpuid_CheckAndRead(Cx86cpuid* p);
int x86cpuid_GetFirm(const Cx86cpuid* p);
#define x86cpuid_GetFamily(ver) (((ver >> 16) & 0xFF0) | ((ver >> 8) & 0xF))
#define x86cpuid_GetModel(ver) (((ver >> 12) & 0xF0) | ((ver >> 4) & 0xF))

8
SevenZip/Delta.c
View file

@ -5,21 +5,21 @@
#include "Delta.h"
void Delta_Init(Byte *state)
void Delta_Init(Byte* state)
{
unsigned i;
for (i = 0; i < DELTA_STATE_SIZE; i++)
state[i] = 0;
}
static void MyMemCpy(Byte *dest, const Byte *src, unsigned size)
static void MyMemCpy(Byte* dest, const Byte* src, unsigned size)
{
unsigned i;
for (i = 0; i < size; i++)
dest[i] = src[i];
}
void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size)
void Delta_Encode(Byte* state, unsigned delta, Byte* data, SizeT size)
{
Byte buf[DELTA_STATE_SIZE];
unsigned j = 0;
@ -42,7 +42,7 @@ void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size)
MyMemCpy(state + delta - j, buf, j);
}
void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size)
void Delta_Decode(Byte* state, unsigned delta, Byte* data, SizeT size)
{
Byte buf[DELTA_STATE_SIZE];
unsigned j = 0;

6
SevenZip/Delta.h
View file

@ -10,9 +10,9 @@ EXTERN_C_BEGIN
#define DELTA_STATE_SIZE 256
void Delta_Init(Byte *state);
void Delta_Encode(Byte *state, unsigned delta, Byte *data, SizeT size);
void Delta_Decode(Byte *state, unsigned delta, Byte *data, SizeT size);
void Delta_Init(Byte* state);
void Delta_Encode(Byte* state, unsigned delta, Byte* data, SizeT size);
void Delta_Decode(Byte* state, unsigned delta, Byte* data, SizeT size);
EXTERN_C_END

30
SevenZip/Lzma2Dec.c
View file

@ -60,7 +60,7 @@ typedef enum
LZMA2_STATE_ERROR
} ELzma2State;
static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)
static SRes Lzma2Dec_GetOldProps(Byte prop, Byte* props)
{
UInt32 dicSize;
if (prop > 40)
@ -74,21 +74,21 @@ static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)
return SZ_OK;
}
SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc)
SRes Lzma2Dec_AllocateProbs(CLzma2Dec* p, Byte prop, ISzAlloc* alloc)
{
Byte props[LZMA_PROPS_SIZE];
RINOK(Lzma2Dec_GetOldProps(prop, props));
return LzmaDec_AllocateProbs(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
}
SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc)
SRes Lzma2Dec_Allocate(CLzma2Dec* p, Byte prop, ISzAlloc* alloc)
{
Byte props[LZMA_PROPS_SIZE];
RINOK(Lzma2Dec_GetOldProps(prop, props));
return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
}
void Lzma2Dec_Init(CLzma2Dec *p)
void Lzma2Dec_Init(CLzma2Dec* p)
{
p->state = LZMA2_STATE_CONTROL;
p->needInitDic = True;
@ -97,7 +97,7 @@ void Lzma2Dec_Init(CLzma2Dec *p)
LzmaDec_Init(&p->decoder);
}
static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec* p, Byte b)
{
switch (p->state)
{
@ -135,8 +135,9 @@ static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
p->packSize |= (UInt32)b;
p->packSize++;
PRF(printf(" %8u", (unsigned)p->packSize));
return LZMA2_IS_THERE_PROP(LZMA2_GET_LZMA_MODE(p)) ? LZMA2_STATE_PROP:
(p->needInitProp ? LZMA2_STATE_ERROR : LZMA2_STATE_DATA);
return LZMA2_IS_THERE_PROP(LZMA2_GET_LZMA_MODE(p))
? LZMA2_STATE_PROP
: (p->needInitProp ? LZMA2_STATE_ERROR : LZMA2_STATE_DATA);
case LZMA2_STATE_PROP:
{
@ -158,7 +159,7 @@ static ELzma2State Lzma2Dec_UpdateState(CLzma2Dec *p, Byte b)
return LZMA2_STATE_ERROR;
}
static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size)
static void LzmaDec_UpdateWithUncompressed(CLzmaDec* p, const Byte* src, SizeT size)
{
memcpy(p->dic + p->dicPos, src, size);
p->dicPos += size;
@ -167,10 +168,10 @@ static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT s
p->processedPos += (UInt32)size;
}
void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState);
void LzmaDec_InitDicAndState(CLzmaDec* p, Bool initDic, Bool initState);
SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
SRes Lzma2Dec_DecodeToDic(CLzma2Dec* p, SizeT dicLimit,
const Byte* src, SizeT* srcLen, ELzmaFinishMode finishMode, ELzmaStatus* status)
{
SizeT inSize = *srcLen;
*srcLen = 0;
@ -316,7 +317,8 @@ SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
return SZ_OK;
}
SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
SRes Lzma2Dec_DecodeToBuf(CLzma2Dec* p, Byte* dest, SizeT* destLen, const Byte* src, SizeT* srcLen,
ELzmaFinishMode finishMode, ELzmaStatus* status)
{
SizeT outSize = *destLen, inSize = *srcLen;
*srcLen = *destLen = 0;
@ -355,8 +357,8 @@ SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen, const Byte *
}
}
SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc)
SRes Lzma2Decode(Byte* dest, SizeT* destLen, const Byte* src, SizeT* srcLen,
Byte prop, ELzmaFinishMode finishMode, ELzmaStatus* status, ISzAlloc* alloc)
{
CLzma2Dec p;
SRes res;

18
SevenZip/Lzma2Dec.h
View file

@ -26,9 +26,9 @@ typedef struct
#define Lzma2Dec_FreeProbs(p, alloc) LzmaDec_FreeProbs(&(p)->decoder, alloc);
#define Lzma2Dec_Free(p, alloc) LzmaDec_Free(&(p)->decoder, alloc);
SRes Lzma2Dec_AllocateProbs(CLzma2Dec *p, Byte prop, ISzAlloc *alloc);
SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAlloc *alloc);
void Lzma2Dec_Init(CLzma2Dec *p);
SRes Lzma2Dec_AllocateProbs(CLzma2Dec* p, Byte prop, ISzAlloc* alloc);
SRes Lzma2Dec_Allocate(CLzma2Dec* p, Byte prop, ISzAlloc* alloc);
void Lzma2Dec_Init(CLzma2Dec* p);
/*
@ -46,11 +46,11 @@ Returns:
SZ_ERROR_DATA - Data error
*/
SRes Lzma2Dec_DecodeToDic(CLzma2Dec *p, SizeT dicLimit,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
SRes Lzma2Dec_DecodeToDic(CLzma2Dec* p, SizeT dicLimit,
const Byte* src, SizeT* srcLen, ELzmaFinishMode finishMode, ELzmaStatus* status);
SRes Lzma2Dec_DecodeToBuf(CLzma2Dec *p, Byte *dest, SizeT *destLen,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
SRes Lzma2Dec_DecodeToBuf(CLzma2Dec* p, Byte* dest, SizeT* destLen,
const Byte* src, SizeT* srcLen, ELzmaFinishMode finishMode, ELzmaStatus* status);
/* ---------- One Call Interface ---------- */
@ -72,8 +72,8 @@ Returns:
SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
*/
SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAlloc *alloc);
SRes Lzma2Decode(Byte* dest, SizeT* destLen, const Byte* src, SizeT* srcLen,
Byte prop, ELzmaFinishMode finishMode, ELzmaStatus* status, ISzAlloc* alloc);
EXTERN_C_END

111
SevenZip/LzmaDec.c
View file

@ -137,9 +137,9 @@ Out:
= kMatchSpecLenStart + 2 : State Init Marker (unused now)
*/
static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec* p, SizeT limit, const Byte* bufLimit)
{
CLzmaProb *probs = p->probs;
CLzmaProb* probs = p->probs;
unsigned state = p->state;
UInt32 rep0 = p->reps[0], rep1 = p->reps[1], rep2 = p->reps[2], rep3 = p->reps[3];
@ -147,7 +147,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
unsigned lpMask = ((unsigned)1 << (p->prop.lp)) - 1;
unsigned lc = p->prop.lc;
Byte *dic = p->dic;
Byte* dic = p->dic;
SizeT dicBufSize = p->dicBufSize;
SizeT dicPos = p->dicPos;
@ -155,13 +155,13 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
UInt32 checkDicSize = p->checkDicSize;
unsigned len = 0;
const Byte *buf = p->buf;
const Byte* buf = p->buf;
UInt32 range = p->range;
UInt32 code = p->code;
do
{
CLzmaProb *prob;
CLzmaProb* prob;
UInt32 bound;
unsigned ttt;
unsigned posState = processedPos & pbMask;
@ -181,9 +181,9 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
{
state -= (state < 4) ? state : 3;
symbol = 1;
#ifdef _LZMA_SIZE_OPT
#ifdef _LZMA_SIZE_OPT
do { NORMAL_LITER_DEC } while (symbol < 0x100);
#else
#else
NORMAL_LITER_DEC
NORMAL_LITER_DEC
NORMAL_LITER_DEC
@ -192,7 +192,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
NORMAL_LITER_DEC
NORMAL_LITER_DEC
NORMAL_LITER_DEC
#endif
#endif
}
else
{
@ -200,7 +200,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
unsigned offs = 0x100;
state -= (state < 10) ? 3 : 6;
symbol = 1;
#ifdef _LZMA_SIZE_OPT
#ifdef _LZMA_SIZE_OPT
do
{
unsigned bit;
@ -208,10 +208,10 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
MATCHED_LITER_DEC
}
while (symbol < 0x100);
#else
#else
{
unsigned bit;
CLzmaProb *probLit;
CLzmaProb* probLit;
MATCHED_LITER_DEC
MATCHED_LITER_DEC
MATCHED_LITER_DEC
@ -221,7 +221,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
MATCHED_LITER_DEC
MATCHED_LITER_DEC
}
#endif
#endif
}
dic[dicPos++] = (Byte)symbol;
@ -292,7 +292,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
prob = probs + RepLenCoder;
}
#ifdef _LZMA_SIZE_OPT
#ifdef _LZMA_SIZE_OPT
{
unsigned lim, offset;
CLzmaProb *probLen = prob + LenChoice;
@ -325,9 +325,9 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
TREE_DECODE(probLen, lim, len);
len += offset;
}
#else
#else
{
CLzmaProb *probLen = prob + LenChoice;
CLzmaProb* probLen = prob + LenChoice;
IF_BIT_0(probLen)
{
UPDATE_0(probLen);
@ -360,7 +360,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
}
}
}
#endif
#endif
if (state >= kNumStates)
{
@ -382,7 +382,7 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
unsigned i = 1;
do
{
GET_BIT2(prob + i, i, ; , distance |= mask);
GET_BIT2(prob + i, i, ;, distance |= mask);
mask <<= 1;
}
while (--numDirectBits != 0);
@ -417,10 +417,10 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
distance <<= kNumAlignBits;
{
unsigned i = 1;
GET_BIT2(prob + i, i, ; , distance |= 1);
GET_BIT2(prob + i, i, ; , distance |= 2);
GET_BIT2(prob + i, i, ; , distance |= 4);
GET_BIT2(prob + i, i, ; , distance |= 8);
GET_BIT2(prob + i, i, ;, distance |= 1);
GET_BIT2(prob + i, i, ;, distance |= 2);
GET_BIT2(prob + i, i, ;, distance |= 4);
GET_BIT2(prob + i, i, ;, distance |= 8);
}
if (distance == (UInt32)0xFFFFFFFF)
{
@ -472,9 +472,9 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
len -= curLen;
if (curLen <= dicBufSize - pos)
{
Byte *dest = dic + dicPos;
Byte* dest = dic + dicPos;
ptrdiff_t src = (ptrdiff_t)pos - (ptrdiff_t)dicPos;
const Byte *lim = dest + curLen;
const Byte* lim = dest + curLen;
dicPos += curLen;
do
*(dest) = (Byte)*(dest + src);
@ -512,11 +512,11 @@ static int MY_FAST_CALL LzmaDec_DecodeReal(CLzmaDec *p, SizeT limit, const Byte
return SZ_OK;
}
static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec* p, SizeT limit)
{
if (p->remainLen != 0 && p->remainLen < kMatchSpecLenStart)
{
Byte *dic = p->dic;
Byte* dic = p->dic;
SizeT dicPos = p->dicPos;
SizeT dicBufSize = p->dicBufSize;
unsigned len = p->remainLen;
@ -540,7 +540,7 @@ static void MY_FAST_CALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
}
}
static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec* p, SizeT limit, const Byte* bufLimit)
{
do
{
@ -569,23 +569,24 @@ static int MY_FAST_CALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte
typedef enum
{
DUMMY_ERROR, /* unexpected end of input stream */
DUMMY_ERROR,
/* unexpected end of input stream */
DUMMY_LIT,
DUMMY_MATCH,
DUMMY_REP
} ELzmaDummy;
static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inSize)
static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec* p, const Byte* buf, SizeT inSize)
{
UInt32 range = p->range;
UInt32 code = p->code;
const Byte *bufLimit = buf + inSize;
const CLzmaProb *probs = p->probs;
const Byte* bufLimit = buf + inSize;
const CLzmaProb* probs = p->probs;
unsigned state = p->state;
ELzmaDummy res;
{
const CLzmaProb *prob;
const CLzmaProb* prob;
UInt32 bound;
unsigned ttt;
unsigned posState = (p->processedPos) & ((1 << p->prop.pb) - 1);
@ -606,7 +607,8 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
if (state < kNumLitStates)
{
unsigned symbol = 1;
do { GET_BIT_CHECK(prob + symbol, symbol) } while (symbol < 0x100);
do { GET_BIT_CHECK(prob + symbol, symbol) }
while (symbol < 0x100);
}
else
{
@ -617,7 +619,7 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
do
{
unsigned bit;
const CLzmaProb *probLit;
const CLzmaProb* probLit;
matchByte <<= 1;
bit = (matchByte & offs);
probLit = prob + offs + bit + symbol;
@ -687,7 +689,7 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
}
{
unsigned limit, offset;
const CLzmaProb *probLen = prob + LenChoice;
const CLzmaProb* probLen = prob + LenChoice;
IF_BIT_0_CHECK(probLen)
{
UPDATE_0_CHECK;
@ -766,7 +768,7 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
}
void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
void LzmaDec_InitDicAndState(CLzmaDec* p, Bool initDic, Bool initState)
{
p->needFlush = 1;
p->remainLen = 0;
@ -782,17 +784,17 @@ void LzmaDec_InitDicAndState(CLzmaDec *p, Bool initDic, Bool initState)
p->needInitState = 1;
}
void LzmaDec_Init(CLzmaDec *p)
void LzmaDec_Init(CLzmaDec* p)
{
p->dicPos = 0;
LzmaDec_InitDicAndState(p, True, True);
}
static void LzmaDec_InitStateReal(CLzmaDec *p)
static void LzmaDec_InitStateReal(CLzmaDec* p)
{
SizeT numProbs = LzmaProps_GetNumProbs(&p->prop);
SizeT i;
CLzmaProb *probs = p->probs;
CLzmaProb* probs = p->probs;
for (i = 0; i < numProbs; i++)
probs[i] = kBitModelTotal >> 1;
p->reps[0] = p->reps[1] = p->reps[2] = p->reps[3] = 1;
@ -800,8 +802,8 @@ static void LzmaDec_InitStateReal(CLzmaDec *p)
p->needInitState = 0;
}
SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *srcLen,
ELzmaFinishMode finishMode, ELzmaStatus *status)
SRes LzmaDec_DecodeToDic(CLzmaDec* p, SizeT dicLimit, const Byte* src, SizeT* srcLen,
ELzmaFinishMode finishMode, ELzmaStatus* status)
{
SizeT inSize = *srcLen;
(*srcLen) = 0;
@ -861,7 +863,7 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
if (p->tempBufSize == 0)
{
SizeT processed;
const Byte *bufLimit;
const Byte* bufLimit;
if (inSize < LZMA_REQUIRED_INPUT_MAX || checkEndMarkNow)
{
int dummyRes = LzmaDec_TryDummy(p, src, inSize);
@ -935,7 +937,8 @@ SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, const Byte *src, SizeT *sr
return (p->code == 0) ? SZ_OK : SZ_ERROR_DATA;
}
SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status)
SRes LzmaDec_DecodeToBuf(CLzmaDec* p, Byte* dest, SizeT* destLen, const Byte* src, SizeT* srcLen,
ELzmaFinishMode finishMode, ELzmaStatus* status)
{
SizeT outSize = *destLen;
SizeT inSize = *srcLen;
@ -975,25 +978,25 @@ SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, const Byte *sr
}
}
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc)
void LzmaDec_FreeProbs(CLzmaDec* p, ISzAlloc* alloc)
{
alloc->Free(alloc, p->probs);
p->probs = NULL;
}
static void LzmaDec_FreeDict(CLzmaDec *p, ISzAlloc *alloc)
static void LzmaDec_FreeDict(CLzmaDec* p, ISzAlloc* alloc)
{
alloc->Free(alloc, p->dic);
p->dic = NULL;
}
void LzmaDec_Free(CLzmaDec *p, ISzAlloc *alloc)
void LzmaDec_Free(CLzmaDec* p, ISzAlloc* alloc)
{
LzmaDec_FreeProbs(p, alloc);
LzmaDec_FreeDict(p, alloc);
}
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
SRes LzmaProps_Decode(CLzmaProps* p, const Byte* data, unsigned size)
{
UInt32 dicSize;
Byte d;
@ -1019,13 +1022,13 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
return SZ_OK;
}
static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAlloc *alloc)
static SRes LzmaDec_AllocateProbs2(CLzmaDec* p, const CLzmaProps* propNew, ISzAlloc* alloc)
{
UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
if (!p->probs || numProbs != p->numProbs)
{
LzmaDec_FreeProbs(p, alloc);
p->probs = (CLzmaProb *)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));
p->probs = (CLzmaProb*)alloc->Alloc(alloc, numProbs * sizeof(CLzmaProb));
p->numProbs = numProbs;
if (!p->probs)
return SZ_ERROR_MEM;
@ -1033,7 +1036,7 @@ static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAl
return SZ_OK;
}
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
SRes LzmaDec_AllocateProbs(CLzmaDec* p, const Byte* props, unsigned propsSize, ISzAlloc* alloc)
{
CLzmaProps propNew;
RINOK(LzmaProps_Decode(&propNew, props, propsSize));
@ -1042,7 +1045,7 @@ SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, I
return SZ_OK;
}
SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc)
SRes LzmaDec_Allocate(CLzmaDec* p, const Byte* props, unsigned propsSize, ISzAlloc* alloc)
{
CLzmaProps propNew;
SizeT dicBufSize;
@ -1062,7 +1065,7 @@ SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAll
if (!p->dic || dicBufSize != p->dicBufSize)
{
LzmaDec_FreeDict(p, alloc);
p->dic = (Byte *)alloc->Alloc(alloc, dicBufSize);
p->dic = (Byte*)alloc->Alloc(alloc, dicBufSize);
if (!p->dic)
{
LzmaDec_FreeProbs(p, alloc);
@ -1074,9 +1077,9 @@ SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAll
return SZ_OK;
}
SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
ELzmaStatus *status, ISzAlloc *alloc)
SRes LzmaDecode(Byte* dest, SizeT* destLen, const Byte* src, SizeT* srcLen,
const Byte* propData, unsigned propSize, ELzmaFinishMode finishMode,
ELzmaStatus* status, ISzAlloc* alloc)
{
CLzmaDec p;
SRes res;

47
SevenZip/LzmaDec.h
View file

@ -35,7 +35,7 @@ Returns:
SZ_ERROR_UNSUPPORTED - Unsupported properties
*/
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
SRes LzmaProps_Decode(CLzmaProps* p, const Byte* data, unsigned size);
/* ---------- LZMA Decoder state ---------- */
@ -48,9 +48,9 @@ SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
typedef struct
{
CLzmaProps prop;
CLzmaProb *probs;
Byte *dic;
const Byte *buf;
CLzmaProb* probs;
Byte* dic;
const Byte* buf;
UInt32 range, code;
SizeT dicPos;
SizeT dicBufSize;
@ -68,7 +68,7 @@ typedef struct
#define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; }
void LzmaDec_Init(CLzmaDec *p);
void LzmaDec_Init(CLzmaDec* p);
/* There are two types of LZMA streams:
0) Stream with end mark. That end mark adds about 6 bytes to compressed size.
@ -76,7 +76,8 @@ void LzmaDec_Init(CLzmaDec *p);
typedef enum
{
LZMA_FINISH_ANY, /* finish at any point */
LZMA_FINISH_ANY,
/* finish at any point */
LZMA_FINISH_END /* block must be finished at the end */
} ELzmaFinishMode;
@ -97,10 +98,14 @@ typedef enum
typedef enum
{
LZMA_STATUS_NOT_SPECIFIED, /* use main error code instead */
LZMA_STATUS_FINISHED_WITH_MARK, /* stream was finished with end mark. */
LZMA_STATUS_NOT_FINISHED, /* stream was not finished */
LZMA_STATUS_NEEDS_MORE_INPUT, /* you must provide more input bytes */
LZMA_STATUS_NOT_SPECIFIED,
/* use main error code instead */
LZMA_STATUS_FINISHED_WITH_MARK,
/* stream was finished with end mark. */
LZMA_STATUS_NOT_FINISHED,
/* stream was not finished */
LZMA_STATUS_NEEDS_MORE_INPUT,
/* you must provide more input bytes */
LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK /* there is probability that stream was finished without end mark */
} ELzmaStatus;
@ -129,11 +134,11 @@ LzmaDec_Allocate* can return:
SZ_ERROR_UNSUPPORTED - Unsupported properties
*/
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc);
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);
SRes LzmaDec_AllocateProbs(CLzmaDec* p, const Byte* props, unsigned propsSize, ISzAlloc* alloc);
void LzmaDec_FreeProbs(CLzmaDec* p, ISzAlloc* alloc);
SRes LzmaDec_Allocate(CLzmaDec *state, const Byte *prop, unsigned propsSize, ISzAlloc *alloc);
void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);
SRes LzmaDec_Allocate(CLzmaDec* state, const Byte* prop, unsigned propsSize, ISzAlloc* alloc);
void LzmaDec_Free(CLzmaDec* state, ISzAlloc* alloc);
/* ---------- Dictionary Interface ---------- */
@ -176,8 +181,8 @@ Returns:
SZ_ERROR_DATA - Data error
*/
SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
SRes LzmaDec_DecodeToDic(CLzmaDec* p, SizeT dicLimit,
const Byte* src, SizeT* srcLen, ELzmaFinishMode finishMode, ELzmaStatus* status);
/* ---------- Buffer Interface ---------- */
@ -193,8 +198,8 @@ finishMode:
LZMA_FINISH_END - Stream must be finished after (*destLen).
*/
SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
SRes LzmaDec_DecodeToBuf(CLzmaDec* p, Byte* dest, SizeT* destLen,
const Byte* src, SizeT* srcLen, ELzmaFinishMode finishMode, ELzmaStatus* status);
/* ---------- One Call Interface ---------- */
@ -218,9 +223,9 @@ Returns:
SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
*/
SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
ELzmaStatus *status, ISzAlloc *alloc);
SRes LzmaDecode(Byte* dest, SizeT* destLen, const Byte* src, SizeT* srcLen,
const Byte* propData, unsigned propSize, ELzmaFinishMode finishMode,
ELzmaStatus* status, ISzAlloc* alloc);
EXTERN_C_END

30
SevenZip/Ppmd.h
View file

@ -53,28 +53,28 @@ typedef struct
#pragma pack(pop)
typedef
#ifdef PPMD_32BIT
#ifdef PPMD_32BIT
CPpmd_State *
#else
UInt32
#endif
CPpmd_State_Ref;
#else
UInt32
#endif
CPpmd_State_Ref;
typedef
#ifdef PPMD_32BIT
#ifdef PPMD_32BIT
void *
#else
UInt32
#endif
CPpmd_Void_Ref;
#else
UInt32
#endif
CPpmd_Void_Ref;
typedef
#ifdef PPMD_32BIT
#ifdef PPMD_32BIT
Byte *
#else
UInt32
#endif
CPpmd_Byte_Ref;
#else
UInt32
#endif
CPpmd_Byte_Ref;
#define PPMD_SetAllBitsIn256Bytes(p) \
{ unsigned z; for (z = 0; z < 256 / sizeof(p[0]); z += 8) { \

161
SevenZip/Ppmd7.c
View file

@ -8,8 +8,8 @@ This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
#include "Ppmd7.h"
const Byte PPMD7_kExpEscape[16] = { 25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2 };
static const UInt16 kInitBinEsc[] = { 0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x5ABC, 0x6632, 0x6051};
const Byte PPMD7_kExpEscape[16] = {25, 14, 9, 7, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 2};
static const UInt16 kInitBinEsc[] = {0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x5ABC, 0x6632, 0x6051};
#define MAX_FREQ 124
#define UNIT_SIZE 12
@ -21,7 +21,7 @@ static const UInt16 kInitBinEsc[] = { 0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x
#ifdef PPMD_32BIT
#define REF(ptr) (ptr)
#else
#define REF(ptr) ((UInt32)((Byte *)(ptr) - (p)->Base))
#define REF(ptr) ((UInt32)((Byte *)(ptr) - (p)->Base))
#endif
#define STATS_REF(ptr) ((CPpmd_State_Ref)REF(ptr))
@ -31,17 +31,17 @@ static const UInt16 kInitBinEsc[] = { 0x3CDD, 0x1F3F, 0x59BF, 0x48F3, 0x64A1, 0x
#define ONE_STATE(ctx) Ppmd7Context_OneState(ctx)
#define SUFFIX(ctx) CTX((ctx)->Suffix)
typedef CPpmd7_Context * CTX_PTR;
typedef CPpmd7_Context* CTX_PTR;
struct CPpmd7_Node_;
typedef
#ifdef PPMD_32BIT
#ifdef PPMD_32BIT
struct CPpmd7_Node_ *
#else
UInt32
#endif
CPpmd7_Node_Ref;
#else
UInt32
#endif
CPpmd7_Node_Ref;
typedef struct CPpmd7_Node_
{
@ -54,10 +54,10 @@ typedef struct CPpmd7_Node_
#ifdef PPMD_32BIT
#define NODE(ptr) (ptr)
#else
#define NODE(offs) ((CPpmd7_Node *)(p->Base + (offs)))
#define NODE(offs) ((CPpmd7_Node *)(p->Base + (offs)))
#endif
void Ppmd7_Construct(CPpmd7 *p)
void Ppmd7_Construct(CPpmd7* p)
{
unsigned i, k, m;
@ -66,7 +66,8 @@ void Ppmd7_Construct(CPpmd7 *p)
for (i = 0, k = 0; i < PPMD_NUM_INDEXES; i++)
{
unsigned step = (i >= 12 ? 4 : (i >> 2) + 1);
do { p->Units2Indx[k++] = (Byte)i; } while (--step);
do { p->Units2Indx[k++] = (Byte)i; }
while (--step);
p->Indx2Units[i] = (Byte)k;
}
@ -88,28 +89,28 @@ void Ppmd7_Construct(CPpmd7 *p)
memset(p->HB2Flag + 0x40, 8, 0x100 - 0x40);
}
void Ppmd7_Free(CPpmd7 *p, ISzAlloc *alloc)
void Ppmd7_Free(CPpmd7* p, ISzAlloc* alloc)
{
alloc->Free(alloc, p->Base);
p->Size = 0;
p->Base = 0;
}
Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAlloc *alloc)
Bool Ppmd7_Alloc(CPpmd7* p, UInt32 size, ISzAlloc* alloc)
{
if (p->Base == 0 || p->Size != size)
{
Ppmd7_Free(p, alloc);
p->AlignOffset =
#ifdef PPMD_32BIT
#ifdef PPMD_32BIT
(4 - size) & 3;
#else
#else
4 - (size & 3);
#endif
if ((p->Base = (Byte *)alloc->Alloc(alloc, p->AlignOffset + size
#ifndef PPMD_32BIT
#endif
if ((p->Base = (Byte*)alloc->Alloc(alloc, p->AlignOffset + size
#ifndef PPMD_32BIT
+ UNIT_SIZE
#endif
#endif
)) == 0)
return False;
p->Size = size;
@ -117,39 +118,39 @@ Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAlloc *alloc)
return True;
}
static void InsertNode(CPpmd7 *p, void *node, unsigned indx)
static void InsertNode(CPpmd7* p, void* node, unsigned indx)
{
*((CPpmd_Void_Ref *)node) = p->FreeList[indx];
*((CPpmd_Void_Ref*)node) = p->FreeList[indx];
p->FreeList[indx] = REF(node);
}
static void *RemoveNode(CPpmd7 *p, unsigned indx)
static void* RemoveNode(CPpmd7* p, unsigned indx)
{
CPpmd_Void_Ref *node = (CPpmd_Void_Ref *)Ppmd7_GetPtr(p, p->FreeList[indx]);
CPpmd_Void_Ref* node = (CPpmd_Void_Ref*)Ppmd7_GetPtr(p, p->FreeList[indx]);
p->FreeList[indx] = *node;
return node;
}
static void SplitBlock(CPpmd7 *p, void *ptr, unsigned oldIndx, unsigned newIndx)
static void SplitBlock(CPpmd7* p, void* ptr, unsigned oldIndx, unsigned newIndx)
{
unsigned i, nu = I2U(oldIndx) - I2U(newIndx);
ptr = (Byte *)ptr + U2B(I2U(newIndx));
ptr = (Byte*)ptr + U2B(I2U(newIndx));
if (I2U(i = U2I(nu)) != nu)
{
unsigned k = I2U(--i);
InsertNode(p, ((Byte *)ptr) + U2B(k), nu - k - 1);
InsertNode(p, ((Byte*)ptr) + U2B(k), nu - k - 1);
}
InsertNode(p, ptr, i);
}
static void GlueFreeBlocks(CPpmd7 *p)
static void GlueFreeBlocks(CPpmd7* p)
{
#ifdef PPMD_32BIT
#ifdef PPMD_32BIT
CPpmd7_Node headItem;
CPpmd7_Node_Ref head = &headItem;
#else
#else
CPpmd7_Node_Ref head = p->AlignOffset + p->Size;
#endif
#endif
CPpmd7_Node_Ref n = head;
unsigned i;
@ -164,10 +165,10 @@ static void GlueFreeBlocks(CPpmd7 *p)
p->FreeList[i] = 0;
while (next != 0)
{
CPpmd7_Node *node = NODE(next);
CPpmd7_Node* node = NODE(next);
node->Next = n;
n = NODE(n)->Prev = next;
next = *(const CPpmd7_Node_Ref *)node;
next = *(const CPpmd7_Node_Ref*)node;
node->Stamp = 0;
node->NU = (UInt16)nu;
}
@ -176,16 +177,16 @@ static void GlueFreeBlocks(CPpmd7 *p)
NODE(head)->Next = n;
NODE(n)->Prev = head;
if (p->LoUnit != p->HiUnit)
((CPpmd7_Node *)p->LoUnit)->Stamp = 1;
((CPpmd7_Node*)p->LoUnit)->Stamp = 1;
/* Glue free blocks */
while (n != head)
{
CPpmd7_Node *node = NODE(n);
CPpmd7_Node* node = NODE(n);
UInt32 nu = (UInt32)node->NU;
for (;;)
{
CPpmd7_Node *node2 = NODE(n) + nu;
CPpmd7_Node* node2 = NODE(n) + nu;
nu += node2->NU;
if (node2->Stamp != 0 || nu >= 0x10000)
break;
@ -199,7 +200,7 @@ static void GlueFreeBlocks(CPpmd7 *p)
/* Fill lists of free blocks */
for (n = NODE(head)->Next; n != head;)
{
CPpmd7_Node *node = NODE(n);
CPpmd7_Node* node = NODE(n);
unsigned nu;
CPpmd7_Node_Ref next = node->Next;
for (nu = node->NU; nu > 128; nu -= 128, node += 128)
@ -214,10 +215,10 @@ static void GlueFreeBlocks(CPpmd7 *p)
}
}
static void *AllocUnitsRare(CPpmd7 *p, unsigned indx)
static void* AllocUnitsRare(CPpmd7* p, unsigned indx)
{
unsigned i;
void *retVal;
void* retVal;
if (p->GlueCount == 0)
{
GlueFreeBlocks(p);
@ -240,7 +241,7 @@ static void *AllocUnitsRare(CPpmd7 *p, unsigned indx)
return retVal;
}
static void *AllocUnits(CPpmd7 *p, unsigned indx)
static void* AllocUnits(CPpmd7* p, unsigned indx)
{
UInt32 numBytes;
if (p->FreeList[indx] != 0)
@ -248,7 +249,7 @@ static void *AllocUnits(CPpmd7 *p, unsigned indx)
numBytes = U2B(I2U(indx));
if (numBytes <= (UInt32)(p->HiUnit - p->LoUnit))
{
void *retVal = p->LoUnit;
void* retVal = p->LoUnit;
p->LoUnit += numBytes;
return retVal;
}
@ -259,7 +260,7 @@ static void *AllocUnits(CPpmd7 *p, unsigned indx)
{ UInt32 *d = (UInt32 *)dest; const UInt32 *s = (const UInt32 *)src; UInt32 n = num; \
do { d[0] = s[0]; d[1] = s[1]; d[2] = s[2]; s += 3; d += 3; } while (--n); }
static void *ShrinkUnits(CPpmd7 *p, void *oldPtr, unsigned oldNU, unsigned newNU)
static void* ShrinkUnits(CPpmd7* p, void* oldPtr, unsigned oldNU, unsigned newNU)
{
unsigned i0 = U2I(oldNU);
unsigned i1 = U2I(newNU);
@ -267,7 +268,7 @@ static void *ShrinkUnits(CPpmd7 *p, void *oldPtr, unsigned oldNU, unsigned newNU
return oldPtr;
if (p->FreeList[i1] != 0)
{
void *ptr = RemoveNode(p, i1);
void* ptr = RemoveNode(p, i1);
MyMem12Cpy(ptr, oldPtr, newNU);
InsertNode(p, oldPtr, i0);
return ptr;
@ -278,13 +279,13 @@ static void *ShrinkUnits(CPpmd7 *p, void *oldPtr, unsigned oldNU, unsigned newNU
#define SUCCESSOR(p) ((CPpmd_Void_Ref)((p)->SuccessorLow | ((UInt32)(p)->SuccessorHigh << 16)))
static void SetSuccessor(CPpmd_State *p, CPpmd_Void_Ref v)
static void SetSuccessor(CPpmd_State* p, CPpmd_Void_Ref v)
{
(p)->SuccessorLow = (UInt16)((UInt32)(v) & 0xFFFF);
(p)->SuccessorHigh = (UInt16)(((UInt32)(v) >> 16) & 0xFFFF);
}
static void RestartModel(CPpmd7 *p)
static void RestartModel(CPpmd7* p)
{
unsigned i, k, m;
@ -302,12 +303,12 @@ static void RestartModel(CPpmd7 *p)
p->MinContext->Suffix = 0;
p->MinContext->NumStats = 256;
p->MinContext->SummFreq = 256 + 1;
p->FoundState = (CPpmd_State *)p->LoUnit; /* AllocUnits(p, PPMD_NUM_INDEXES - 1); */
p->FoundState = (CPpmd_State*)p->LoUnit; /* AllocUnits(p, PPMD_NUM_INDEXES - 1); */
p->LoUnit += U2B(256 / 2);
p->MinContext->Stats = REF(p->FoundState);
for (i = 0; i < 256; i++)
{
CPpmd_State *s = &p->FoundState[i];
CPpmd_State* s = &p->FoundState[i];
s->Symbol = (Byte)i;
s->Freq = 1;
SetSuccessor(s, 0);
@ -316,7 +317,7 @@ static void RestartModel(CPpmd7 *p)
for (i = 0; i < 128; i++)
for (k = 0; k < 8; k++)
{
UInt16 *dest = p->BinSumm[i] + k;
UInt16* dest = p->BinSumm[i] + k;
UInt16 val = (UInt16)(PPMD_BIN_SCALE - kInitBinEsc[k] / (i + 2));
for (m = 0; m < 64; m += 8)
dest[m] = val;
@ -325,13 +326,13 @@ static void RestartModel(CPpmd7 *p)
for (i = 0; i < 25; i++)
for (k = 0; k < 16; k++)
{
CPpmd_See *s = &p->See[i][k];
CPpmd_See* s = &p->See[i][k];
s->Summ = (UInt16)((5 * i + 10) << (s->Shift = PPMD_PERIOD_BITS - 4));
s->Count = 4;
}
}
void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder)
void Ppmd7_Init(CPpmd7* p, unsigned maxOrder)
{
p->MaxOrder = maxOrder;
RestartModel(p);
@ -340,12 +341,12 @@ void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder)
p->DummySee.Count = 64; /* unused */
}
static CTX_PTR CreateSuccessors(CPpmd7 *p, Bool skip)
static CTX_PTR CreateSuccessors(CPpmd7* p, Bool skip)
{
CPpmd_State upState;
CTX_PTR c = p->MinContext;
CPpmd_Byte_Ref upBranch = (CPpmd_Byte_Ref)SUCCESSOR(p->FoundState);
CPpmd_State *ps[PPMD7_MAX_ORDER];
CPpmd_State* ps[PPMD7_MAX_ORDER];
unsigned numPs = 0;
if (!skip)
@ -354,7 +355,7 @@ static CTX_PTR CreateSuccessors(CPpmd7 *p, Bool skip)
while (c->Suffix)
{
CPpmd_Void_Ref successor;
CPpmd_State *s;
CPpmd_State* s;
c = SUFFIX(c);
if (c->NumStats != 1)
{
@ -373,7 +374,7 @@ static CTX_PTR CreateSuccessors(CPpmd7 *p, Bool skip)
ps[numPs++] = s;
}
upState.Symbol = *(const Byte *)Ppmd7_GetPtr(p, upBranch);
upState.Symbol = *(const Byte*)Ppmd7_GetPtr(p, upBranch);
SetSuccessor(&upState, upBranch + 1);
if (c->NumStats == 1)
@ -381,7 +382,7 @@ static CTX_PTR CreateSuccessors(CPpmd7 *p, Bool skip)
else
{
UInt32 cf, s0;
CPpmd_State *s;
CPpmd_State* s;
for (s = STATS(c); s->Symbol != upState.Symbol; s++);
cf = s->Freq - 1;
s0 = c->SummFreq - c->NumStats - cf;
@ -413,14 +414,14 @@ static CTX_PTR CreateSuccessors(CPpmd7 *p, Bool skip)
return c;
}
static void SwapStates(CPpmd_State *t1, CPpmd_State *t2)
static void SwapStates(CPpmd_State* t1, CPpmd_State* t2)
{
CPpmd_State tmp = *t1;
*t1 = *t2;
*t2 = tmp;
}
static void UpdateModel(CPpmd7 *p)
static void UpdateModel(CPpmd7* p)
{
CPpmd_Void_Ref successor, fSuccessor = SUCCESSOR(p->FoundState);
CTX_PTR c;
@ -432,16 +433,17 @@ static void UpdateModel(CPpmd7 *p)
if (c->NumStats == 1)
{
CPpmd_State *s = ONE_STATE(c);
CPpmd_State* s = ONE_STATE(c);
if (s->Freq < 32)
s->Freq++;
}
else
{
CPpmd_State *s = STATS(c);
CPpmd_State* s = STATS(c);
if (s->Symbol != p->FoundState->Symbol)
{
do { s++; } while (s->Symbol != p->FoundState->Symbol);
do { s++; }
while (s->Symbol != p->FoundState->Symbol);
if (s[0].Freq >= s[-1].Freq)
{
SwapStates(&s[0], &s[-1]);
@ -515,8 +517,8 @@ static void UpdateModel(CPpmd7 *p)
unsigned i = U2I(oldNU);
if (i != U2I(oldNU + 1))
{
void *ptr = AllocUnits(p, i + 1);
void *oldPtr;
void* ptr = AllocUnits(p, i + 1);
void* oldPtr;
if (!ptr)
{
RestartModel(p);
@ -532,7 +534,7 @@ static void UpdateModel(CPpmd7 *p)
}
else
{
CPpmd_State *s = (CPpmd_State*)AllocUnits(p, 0);
CPpmd_State* s = (CPpmd_State*)AllocUnits(p, 0);
if (!s)
{
RestartModel(p);
@ -559,7 +561,7 @@ static void UpdateModel(CPpmd7 *p)
c->SummFreq = (UInt16)(c->SummFreq + cf);
}
{
CPpmd_State *s = STATS(c) + ns1;
CPpmd_State* s = STATS(c) + ns1;
SetSuccessor(s, successor);
s->Symbol = p->FoundState->Symbol;
s->Freq = (Byte)cf;
@ -569,11 +571,11 @@ static void UpdateModel(CPpmd7 *p)
p->MaxContext = p->MinContext = CTX(fSuccessor);
}
static void Rescale(CPpmd7 *p)
static void Rescale(CPpmd7* p)
{
unsigned i, adder, sumFreq, escFreq;
CPpmd_State *stats = STATS(p->MinContext);
CPpmd_State *s = p->FoundState;
CPpmd_State* stats = STATS(p->MinContext);
CPpmd_State* s = p->FoundState;
{
CPpmd_State tmp = *s;
for (; s != stats; s--)
@ -594,7 +596,7 @@ static void Rescale(CPpmd7 *p)
sumFreq += s->Freq;
if (s[0].Freq > s[-1].Freq)
{
CPpmd_State *s1 = s;
CPpmd_State* s1 = s;
CPpmd_State tmp = *s1;
do
s1[0] = s1[-1];
@ -608,7 +610,8 @@ static void Rescale(CPpmd7 *p)
{
unsigned numStats = p->MinContext->NumStats;
unsigned n0, n1;
do { i++; } while ((--s)->Freq == 0);
do { i++; }
while ((--s)->Freq == 0);
escFreq += i;
p->MinContext->NumStats = (UInt16)(p->MinContext->NumStats - i);
if (p->MinContext->NumStats == 1)
@ -633,9 +636,9 @@ static void Rescale(CPpmd7 *p)
p->FoundState = STATS(p->MinContext);
}
CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *escFreq)
CPpmd_See* Ppmd7_MakeEscFreq(CPpmd7* p, unsigned numMasked, UInt32* escFreq)
{
CPpmd_See *see;
CPpmd_See* see;
unsigned nonMasked = p->MinContext->NumStats - numMasked;
if (p->MinContext->NumStats != 256)
{
@ -658,18 +661,18 @@ CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *escFreq)
return see;
}
static void NextContext(CPpmd7 *p)
static void NextContext(CPpmd7* p)
{
CTX_PTR c = CTX(SUCCESSOR(p->FoundState));
if (p->OrderFall == 0 && (Byte *)c > p->Text)
if (p->OrderFall == 0 && (Byte*)c > p->Text)
p->MinContext = p->MaxContext = c;
else
UpdateModel(p);
}
void Ppmd7_Update1(CPpmd7 *p)
void Ppmd7_Update1(CPpmd7* p)
{
CPpmd_State *s = p->FoundState;
CPpmd_State* s = p->FoundState;
s->Freq += 4;
p->MinContext->SummFreq += 4;
if (s[0].Freq > s[-1].Freq)
@ -682,7 +685,7 @@ void Ppmd7_Update1(CPpmd7 *p)
NextContext(p);
}
void Ppmd7_Update1_0(CPpmd7 *p)
void Ppmd7_Update1_0(CPpmd7* p)
{
p->PrevSuccess = (2 * p->FoundState->Freq > p->MinContext->SummFreq);
p->RunLength += p->PrevSuccess;
@ -692,15 +695,15 @@ void Ppmd7_Update1_0(CPpmd7 *p)
NextContext(p);
}
void Ppmd7_UpdateBin(CPpmd7 *p)
void Ppmd7_UpdateBin(CPpmd7* p)
{
p->FoundState->Freq = (Byte)(p->FoundState->Freq + (p->FoundState->Freq < 128 ? 1: 0));
p->FoundState->Freq = (Byte)(p->FoundState->Freq + (p->FoundState->Freq < 128 ? 1 : 0));
p->PrevSuccess = 1;
p->RunLength++;
NextContext(p);
}
void Ppmd7_Update2(CPpmd7 *p)
void Ppmd7_Update2(CPpmd7* p)
{
p->MinContext->SummFreq += 4;
if ((p->FoundState->Freq += 4) > MAX_FREQ)

58
SevenZip/Ppmd7.h
View file

@ -22,12 +22,12 @@ EXTERN_C_BEGIN
struct CPpmd7_Context_;
typedef
#ifdef PPMD_32BIT
#ifdef PPMD_32BIT
struct CPpmd7_Context_ *
#else
UInt32
#endif
CPpmd7_Context_Ref;
#else
UInt32
#endif
CPpmd7_Context_Ref;
typedef struct CPpmd7_Context_
{
@ -42,7 +42,7 @@ typedef struct CPpmd7_Context_
typedef struct
{
CPpmd7_Context *MinContext, *MaxContext;
CPpmd_State *FoundState;
CPpmd_State* FoundState;
unsigned OrderFall, InitEsc, PrevSuccess, MaxOrder, HiBitsFlag;
Int32 RunLength, InitRL; /* must be 32-bit at least */
@ -59,10 +59,10 @@ typedef struct
UInt16 BinSumm[128][64];
} CPpmd7;
void Ppmd7_Construct(CPpmd7 *p);
Bool Ppmd7_Alloc(CPpmd7 *p, UInt32 size, ISzAlloc *alloc);
void Ppmd7_Free(CPpmd7 *p, ISzAlloc *alloc);
void Ppmd7_Init(CPpmd7 *p, unsigned maxOrder);
void Ppmd7_Construct(CPpmd7* p);
Bool Ppmd7_Alloc(CPpmd7* p, UInt32 size, ISzAlloc* alloc);
void Ppmd7_Free(CPpmd7* p, ISzAlloc* alloc);
void Ppmd7_Init(CPpmd7* p, unsigned maxOrder);
#define Ppmd7_WasAllocated(p) ((p)->Base != NULL)
@ -75,15 +75,15 @@ extern const Byte PPMD7_kExpEscape[16];
#define Ppmd7_GetContext(p, ptr) (ptr)
#define Ppmd7_GetStats(p, ctx) ((ctx)->Stats)
#else
#define Ppmd7_GetPtr(p, offs) ((void *)((p)->Base + (offs)))
#define Ppmd7_GetContext(p, offs) ((CPpmd7_Context *)Ppmd7_GetPtr((p), (offs)))
#define Ppmd7_GetStats(p, ctx) ((CPpmd_State *)Ppmd7_GetPtr((p), ((ctx)->Stats)))
#define Ppmd7_GetPtr(p, offs) ((void *)((p)->Base + (offs)))
#define Ppmd7_GetContext(p, offs) ((CPpmd7_Context *)Ppmd7_GetPtr((p), (offs)))
#define Ppmd7_GetStats(p, ctx) ((CPpmd_State *)Ppmd7_GetPtr((p), ((ctx)->Stats)))
#endif
void Ppmd7_Update1(CPpmd7 *p);
void Ppmd7_Update1_0(CPpmd7 *p);
void Ppmd7_Update2(CPpmd7 *p);
void Ppmd7_UpdateBin(CPpmd7 *p);
void Ppmd7_Update1(CPpmd7* p);
void Ppmd7_Update1_0(CPpmd7* p);
void Ppmd7_Update2(CPpmd7* p);
void Ppmd7_UpdateBin(CPpmd7* p);
#define Ppmd7_GetBinSumm(p) \
&p->BinSumm[(unsigned)Ppmd7Context_OneState(p->MinContext)->Freq - 1][p->PrevSuccess + \
@ -92,16 +92,16 @@ void Ppmd7_UpdateBin(CPpmd7 *p);
2 * p->HB2Flag[(unsigned)Ppmd7Context_OneState(p->MinContext)->Symbol] + \
((p->RunLength >> 26) & 0x20)]
CPpmd_See *Ppmd7_MakeEscFreq(CPpmd7 *p, unsigned numMasked, UInt32 *scale);
CPpmd_See* Ppmd7_MakeEscFreq(CPpmd7* p, unsigned numMasked, UInt32* scale);
/* ---------- Decode ---------- */
typedef struct
{
UInt32 (*GetThreshold)(void *p, UInt32 total);
void (*Decode)(void *p, UInt32 start, UInt32 size);
UInt32 (*DecodeBit)(void *p, UInt32 size0);
UInt32 (*GetThreshold)(void* p, UInt32 total);
void (*Decode)(void* p, UInt32 start, UInt32 size);
UInt32 (*DecodeBit)(void* p, UInt32 size0);
} IPpmd7_RangeDec;
typedef struct
@ -109,14 +109,14 @@ typedef struct
IPpmd7_RangeDec p;
UInt32 Range;
UInt32 Code;
IByteIn *Stream;
IByteIn* Stream;
} CPpmd7z_RangeDec;
void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p);
Bool Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p);
void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec* p);
Bool Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec* p);
#define Ppmd7z_RangeDec_IsFinishedOK(p) ((p)->Code == 0)
int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc);
int Ppmd7_DecodeSymbol(CPpmd7* p, IPpmd7_RangeDec* rc);
/* ---------- Encode ---------- */
@ -127,13 +127,13 @@ typedef struct
UInt32 Range;
Byte Cache;
UInt64 CacheSize;
IByteOut *Stream;
IByteOut* Stream;
} CPpmd7z_RangeEnc;
void Ppmd7z_RangeEnc_Init(CPpmd7z_RangeEnc *p);
void Ppmd7z_RangeEnc_FlushData(CPpmd7z_RangeEnc *p);
void Ppmd7z_RangeEnc_Init(CPpmd7z_RangeEnc* p);
void Ppmd7z_RangeEnc_FlushData(CPpmd7z_RangeEnc* p);
void Ppmd7_EncodeSymbol(CPpmd7 *p, CPpmd7z_RangeEnc *rc, int symbol);
void Ppmd7_EncodeSymbol(CPpmd7* p, CPpmd7z_RangeEnc* rc, int symbol);
EXTERN_C_END

42
SevenZip/Ppmd7Dec.c
View file

@ -8,49 +8,49 @@ This code is based on PPMd var.H (2001): Dmitry Shkarin : Public domain */
#define kTopValue (1 << 24)
Bool Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec *p)
Bool Ppmd7z_RangeDec_Init(CPpmd7z_RangeDec* p)
{
unsigned i;
p->Code = 0;
p->Range = 0xFFFFFFFF;
if (p->Stream->Read((void *)p->Stream) != 0)
if (p->Stream->Read((void*)p->Stream) != 0)
return False;
for (i = 0; i < 4; i++)
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stream);
p->Code = (p->Code << 8) | p->Stream->Read((void*)p->Stream);
return (p->Code < 0xFFFFFFFF);
}
static UInt32 Range_GetThreshold(void *pp, UInt32 total)
static UInt32 Range_GetThreshold(void* pp, UInt32 total)
{
CPpmd7z_RangeDec *p = (CPpmd7z_RangeDec *)pp;
CPpmd7z_RangeDec* p = (CPpmd7z_RangeDec*)pp;
return (p->Code) / (p->Range /= total);
}
static void Range_Normalize(CPpmd7z_RangeDec *p)
static void Range_Normalize(CPpmd7z_RangeDec* p)
{
if (p->Range < kTopValue)
{
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stream);
p->Code = (p->Code << 8) | p->Stream->Read((void*)p->Stream);
p->Range <<= 8;
if (p->Range < kTopValue)
{
p->Code = (p->Code << 8) | p->Stream->Read((void *)p->Stream);
p->Code = (p->Code << 8) | p->Stream->Read((void*)p->Stream);
p->Range <<= 8;
}
}
}
static void Range_Decode(void *pp, UInt32 start, UInt32 size)
static void Range_Decode(void* pp, UInt32 start, UInt32 size)
{
CPpmd7z_RangeDec *p = (CPpmd7z_RangeDec *)pp;
CPpmd7z_RangeDec* p = (CPpmd7z_RangeDec*)pp;
p->Code -= start * p->Range;
p->Range *= size;
Range_Normalize(p);
}
static UInt32 Range_DecodeBit(void *pp, UInt32 size0)
static UInt32 Range_DecodeBit(void* pp, UInt32 size0)
{
CPpmd7z_RangeDec *p = (CPpmd7z_RangeDec *)pp;
CPpmd7z_RangeDec* p = (CPpmd7z_RangeDec*)pp;
UInt32 newBound = (p->Range >> 14) * size0;
UInt32 symbol;
if (p->Code < newBound)
@ -68,7 +68,7 @@ static UInt32 Range_DecodeBit(void *pp, UInt32 size0)
return symbol;
}
void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p)
void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec* p)
{
p->p.GetThreshold = Range_GetThreshold;
p->p.Decode = Range_Decode;
@ -78,12 +78,12 @@ void Ppmd7z_RangeDec_CreateVTable(CPpmd7z_RangeDec *p)
#define MASK(sym) ((signed char *)charMask)[sym]
int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc)
int Ppmd7_DecodeSymbol(CPpmd7* p, IPpmd7_RangeDec* rc)
{
size_t charMask[256 / sizeof(size_t)];
if (p->MinContext->NumStats != 1)
{
CPpmd_State *s = Ppmd7_GetStats(p, p->MinContext);
CPpmd_State* s = Ppmd7_GetStats(p, p->MinContext);
unsigned i;
UInt32 count, hiCnt;
if ((count = rc->GetThreshold(rc, p->MinContext->SummFreq)) < (hiCnt = s->Freq))
@ -117,11 +117,12 @@ int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc)
PPMD_SetAllBitsIn256Bytes(charMask);
MASK(s->Symbol) = 0;
i = p->MinContext->NumStats - 1;
do { MASK((--s)->Symbol) = 0; } while (--i);
do { MASK((--s)->Symbol) = 0; }
while (--i);
}
else
{
UInt16 *prob = Ppmd7_GetBinSumm(p);
UInt16* prob = Ppmd7_GetBinSumm(p);
if (rc->DecodeBit(rc, *prob) == 0)
{
Byte symbol;
@ -140,7 +141,7 @@ int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc)
{
CPpmd_State *ps[256], *s;
UInt32 freqSum, count, hiCnt;
CPpmd_See *see;
CPpmd_See* see;
unsigned i, num, numMasked = p->MinContext->NumStats;
do
{
@ -170,7 +171,7 @@ int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc)
if (count < hiCnt)
{
Byte symbol;
CPpmd_State **pps = ps;
CPpmd_State** pps = ps;
for (hiCnt = 0; (hiCnt += (*pps)->Freq) <= count; pps++);
s = *pps;
rc->Decode(rc, hiCnt - s->Freq, s->Freq);
@ -184,6 +185,7 @@ int Ppmd7_DecodeSymbol(CPpmd7 *p, IPpmd7_RangeDec *rc)
return -2;
rc->Decode(rc, hiCnt, freqSum - hiCnt);
see->Summ = (UInt16)(see->Summ + freqSum);
do { MASK(ps[--i]->Symbol) = 0; } while (i != 0);
do { MASK(ps[--i]->Symbol) = 0; }
while (i != 0);
}
}