github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-07-30 19:40:37 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

make style

Browse source
This commit is contained in:
Philippe Teuwen 2020-09-30 14:27:19 +02:00
parent 6d62eb88d0
commit c3c59e35cb
27 changed files with 1570 additions and 1590 deletions
Download patch file Download diff file Expand all files Collapse all files

363
common/lz4/lz4.c
View file

@ -299,8 +299,7 @@ typedef enum {
#define LZ4_memcpy(dst, src, size) memcpy(dst, src, size)
#endif
static unsigned LZ4_isLittleEndian(void)
{
static unsigned LZ4_isLittleEndian(void) {
const union { U32 u; BYTE c[4]; } one = { 1 }; /* don't use static : performance detrimental */
return one.c[0];
}
@ -331,36 +330,36 @@ static void LZ4_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = val
#else /* safe and portable access using memcpy() */
static U16 LZ4_read16(const void* memPtr)
{
U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
static U16 LZ4_read16(const void *memPtr) {
U16 val;
LZ4_memcpy(&val, memPtr, sizeof(val));
return val;
}
static U32 LZ4_read32(const void* memPtr)
{
U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
static U32 LZ4_read32(const void *memPtr) {
U32 val;
LZ4_memcpy(&val, memPtr, sizeof(val));
return val;
}
static reg_t LZ4_read_ARCH(const void* memPtr)
{
reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
static reg_t LZ4_read_ARCH(const void *memPtr) {
reg_t val;
LZ4_memcpy(&val, memPtr, sizeof(val));
return val;
}
static void LZ4_write16(void* memPtr, U16 value)
{
static void LZ4_write16(void *memPtr, U16 value) {
LZ4_memcpy(memPtr, &value, sizeof(value));
}
static void LZ4_write32(void* memPtr, U32 value)
{
static void LZ4_write32(void *memPtr, U32 value) {
LZ4_memcpy(memPtr, &value, sizeof(value));
}
#endif /* LZ4_FORCE_MEMORY_ACCESS */
static U16 LZ4_readLE16(const void* memPtr)
{
static U16 LZ4_readLE16(const void *memPtr) {
if (LZ4_isLittleEndian()) {
return LZ4_read16(memPtr);
} else {
@ -369,8 +368,7 @@ static U16 LZ4_readLE16(const void* memPtr)
}
}
static void LZ4_writeLE16(void* memPtr, U16 value)
{
static void LZ4_writeLE16(void *memPtr, U16 value) {
if (LZ4_isLittleEndian()) {
LZ4_write16(memPtr, value);
} else {
@ -382,13 +380,13 @@ static void LZ4_writeLE16(void* memPtr, U16 value)
/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
LZ4_FORCE_O2_INLINE_GCC_PPC64LE
void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)
{
void LZ4_wildCopy8(void *dstPtr, const void *srcPtr, void *dstEnd) {
BYTE *d = (BYTE *)dstPtr;
const BYTE *s = (const BYTE *)srcPtr;
BYTE *const e = (BYTE *)dstEnd;
do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
do { LZ4_memcpy(d, s, 8); d += 8; s += 8; }
while (d < e);
}
static const unsigned inc32table[8] = {0, 1, 2, 1, 0, 4, 4, 4};
@ -411,8 +409,7 @@ static const int dec64table[8] = {0, 0, 0, -1, -4, 1, 2, 3};
#if LZ4_FAST_DEC_LOOP
LZ4_FORCE_O2_INLINE_GCC_PPC64LE void
LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
{
LZ4_memcpy_using_offset_base(BYTE *dstPtr, const BYTE *srcPtr, BYTE *dstEnd, const size_t offset) {
if (offset < 8) {
dstPtr[0] = srcPtr[0];
dstPtr[1] = srcPtr[1];
@ -435,21 +432,20 @@ LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, con
* this version copies two times 16 bytes (instead of one time 32 bytes)
* because it must be compatible with offsets >= 16. */
LZ4_FORCE_O2_INLINE_GCC_PPC64LE void
LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)
{
LZ4_wildCopy32(void *dstPtr, const void *srcPtr, void *dstEnd) {
BYTE *d = (BYTE *)dstPtr;
const BYTE *s = (const BYTE *)srcPtr;
BYTE *const e = (BYTE *)dstEnd;
do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
do { LZ4_memcpy(d, s, 16); LZ4_memcpy(d + 16, s + 16, 16); d += 32; s += 32; }
while (d < e);
}
/* LZ4_memcpy_using_offset() presumes :
* - dstEnd >= dstPtr + MINMATCH
* - there is at least 8 bytes available to write after dstEnd */
LZ4_FORCE_O2_INLINE_GCC_PPC64LE void
LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
{
LZ4_memcpy_using_offset(BYTE *dstPtr, const BYTE *srcPtr, BYTE *dstEnd, const size_t offset) {
BYTE v[8];
assert(dstEnd >= dstPtr + MINMATCH);
@ -486,8 +482,7 @@ LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const si
/*-************************************
* Common functions
**************************************/
static unsigned LZ4_NbCommonBytes (reg_t val)
{
static unsigned LZ4_NbCommonBytes(reg_t val) {
assert(val != 0);
if (LZ4_isLittleEndian()) {
if (sizeof(val) == 8) {
@ -521,7 +516,7 @@ static unsigned LZ4_NbCommonBytes (reg_t val)
return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
# endif
}
} else /* Big Endian CPU */ {
} else { /* Big Endian CPU */
if (sizeof(val) == 8) {
# if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
@ -552,8 +547,10 @@ static unsigned LZ4_NbCommonBytes (reg_t val)
Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.
Note that this code path is never triggered in 32-bits mode. */
unsigned r;
if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }
if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
if (!(val >> by32)) { r = 4; }
else { r = 0; val >>= by32; }
if (!(val >> 16)) { r += 2; val >>= 8; }
else { val >>= 24; }
r += (!val);
return r;
#endif
@ -576,17 +573,18 @@ static unsigned LZ4_NbCommonBytes (reg_t val)
#define STEPSIZE sizeof(reg_t)
LZ4_FORCE_INLINE
unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
{
unsigned LZ4_count(const BYTE *pIn, const BYTE *pMatch, const BYTE *pInLimit) {
const BYTE *const pStart = pIn;
if (likely(pIn < pInLimit - (STEPSIZE - 1))) {
reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
if (!diff) {
pIn+=STEPSIZE; pMatch+=STEPSIZE;
pIn += STEPSIZE;
pMatch += STEPSIZE;
} else {
return LZ4_NbCommonBytes(diff);
} }
}
}
while (likely(pIn < pInLimit - (STEPSIZE - 1))) {
reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
@ -671,16 +669,14 @@ int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
/*-******************************
* Compression functions
********************************/
LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
{
LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType) {
if (tableType == byU16)
return ((sequence * 2654435761U) >> ((MINMATCH * 8) - (LZ4_HASHLOG + 1)));
else
return ((sequence * 2654435761U) >> ((MINMATCH * 8) - LZ4_HASHLOG));
}
LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
{
LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType) {
const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG + 1 : LZ4_HASHLOG;
if (LZ4_isLittleEndian()) {
const U64 prime5bytes = 889523592379ULL;
@ -691,51 +687,51 @@ LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
}
}
LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
{
LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void *const p, tableType_t const tableType) {
if ((sizeof(reg_t) == 8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
return LZ4_hash4(LZ4_read32(p), tableType);
}
LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)
{
switch (tableType)
{
LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void *tableBase, tableType_t const tableType) {
switch (tableType) {
default: /* fallthrough */
case clearedTable: { /* illegal! */ assert(0); return; }
case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
case byPtr:
{ const BYTE **hashTable = (const BYTE **)tableBase; hashTable[h] = NULL; return; }
case byU32:
{ U32 *hashTable = (U32 *) tableBase; hashTable[h] = 0; return; }
case byU16:
{ U16 *hashTable = (U16 *) tableBase; hashTable[h] = 0; return; }
}
}
LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
{
switch (tableType)
{
LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void *tableBase, tableType_t const tableType) {
switch (tableType) {
default: /* fallthrough */
case clearedTable: /* fallthrough */
case byPtr: { /* illegal! */ assert(0); return; }
case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
case byU32:
{ U32 *hashTable = (U32 *) tableBase; hashTable[h] = idx; return; }
case byU16:
{ U16 *hashTable = (U16 *) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
}
}
LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE *p, U32 h,
void *tableBase, tableType_t const tableType,
const BYTE* srcBase)
{
switch (tableType)
{
const BYTE *srcBase) {
switch (tableType) {
case clearedTable: { /* illegal! */ assert(0); return; }
case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = p; return; }
case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = (U32)(p-srcBase); return; }
case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = (U16)(p-srcBase); return; }
case byPtr:
{ const BYTE **hashTable = (const BYTE **)tableBase; hashTable[h] = p; return; }
case byU32:
{ U32 *hashTable = (U32 *) tableBase; hashTable[h] = (U32)(p - srcBase); return; }
case byU16:
{ U16 *hashTable = (U16 *) tableBase; hashTable[h] = (U16)(p - srcBase); return; }
}
}
LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType, const BYTE* srcBase)
{
LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE *p, void *tableBase, tableType_t tableType, const BYTE *srcBase) {
U32 const h = LZ4_hashPosition(p, tableType);
LZ4_putPositionOnHash(p, h, tableBase, tableType, srcBase);
}
@ -746,8 +742,7 @@ LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_
* Assumption 1 : only valid if tableType == byU32 or byU16.
* Assumption 2 : h is presumed valid (within limits of hash table)
*/
LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
{
LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void *tableBase, tableType_t tableType) {
LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
if (tableType == byU32) {
const U32 *const hashTable = (const U32 *) tableBase;
@ -759,11 +754,11 @@ LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_
assert(h < (1U << (LZ4_MEMORY_USAGE - 1)));
return hashTable[h];
}
assert(0); return 0; /* forbidden case */
assert(0);
return 0; /* forbidden case */
}
static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType, const BYTE* srcBase)
{
static const BYTE *LZ4_getPositionOnHash(U32 h, const void *tableBase, tableType_t tableType, const BYTE *srcBase) {
if (tableType == byPtr) { const BYTE *const *hashTable = (const BYTE * const *) tableBase; return hashTable[h]; }
if (tableType == byU32) { const U32 *const hashTable = (const U32 *) tableBase; return hashTable[h] + srcBase; }
{ const U16 *const hashTable = (const U16 *) tableBase; return hashTable[h] + srcBase; } /* default, to ensure a return */
@ -772,8 +767,7 @@ static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType
LZ4_FORCE_INLINE const BYTE *
LZ4_getPosition(const BYTE *p,
const void *tableBase, tableType_t tableType,
const BYTE* srcBase)
{
const BYTE *srcBase) {
U32 const h = LZ4_hashPosition(p, tableType);
return LZ4_getPositionOnHash(h, tableBase, tableType, srcBase);
}
@ -792,8 +786,7 @@ LZ4_prepareTable(LZ4_stream_t_internal* const cctx,
|| ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)
|| ((tableType == byU32) && cctx->currentOffset > 1 GB)
|| tableType == byPtr
|| inputSize >= 4 KB)
{
|| inputSize >= 4 KB) {
DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
cctx->currentOffset = 0;
@ -835,8 +828,7 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
const tableType_t tableType,
const dict_directive dictDirective,
const dictIssue_directive dictIssue,
const int acceleration)
{
const int acceleration) {
int result;
const BYTE *ip = (const BYTE *) source;
@ -898,7 +890,8 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
/* First Byte */
LZ4_putPosition(ip, cctx->hashTable, tableType, base);
ip++; forwardH = LZ4_hashPosition(ip, tableType);
ip++;
forwardH = LZ4_hashPosition(ip, tableType);
/* Main Loop */
for (; ;) {
@ -995,7 +988,8 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
while (((ip > anchor) & (match > lowLimit)) && (unlikely(ip[-1] == match[-1]))) { ip--; match--; }
/* Encode Literals */
{ unsigned const litLength = (unsigned)(ip - anchor);
{
unsigned const litLength = (unsigned)(ip - anchor);
token = op++;
if ((outputDirective == limitedOutput) && /* Check output buffer overflow */
(unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength / 255) > olimit))) {
@ -1011,8 +1005,7 @@ LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
*token = (RUN_MASK << ML_BITS);
for (; len >= 255 ; len -= 255) * op++ = 255;
*op++ = (BYTE)len;
}
else *token = (BYTE)(litLength<<ML_BITS);
} else *token = (BYTE)(litLength << ML_BITS);
/* Copy Literals */
LZ4_wildCopy8(op, anchor, op + litLength);
@ -1041,15 +1034,18 @@ _next_match:
if (maybe_extMem) { /* static test */
DEBUGLOG(6, " with offset=%u (ext if > %i)", offset, (int)(ip - (const BYTE *)source));
assert(offset <= LZ4_DISTANCE_MAX && offset > 0);
LZ4_writeLE16(op, (U16)offset); op+=2;
LZ4_writeLE16(op, (U16)offset);
op += 2;
} else {
DEBUGLOG(6, " with offset=%u (same segment)", (U32)(ip - match));
assert(ip - match <= LZ4_DISTANCE_MAX);
LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
LZ4_writeLE16(op, (U16)(ip - match));
op += 2;
}
/* Encode MatchLength */
{ unsigned matchCode;
{
unsigned matchCode;
if ((dictDirective == usingExtDict || dictDirective == usingDictCtx)
&& (lowLimit == dictionary) /* match within extDict */) {
@ -1179,7 +1175,8 @@ _next_match:
_last_literals:
/* Encode Last Literals */
{ size_t lastRun = (size_t)(iend - anchor);
{
size_t lastRun = (size_t)(iend - anchor);
if ((outputDirective) && /* Check output buffer overflow */
(op + lastRun + 1 + ((lastRun + 255 - RUN_MASK) / 255) > olimit)) {
if (outputDirective == fillOutput) {
@ -1229,8 +1226,7 @@ LZ4_FORCE_INLINE int LZ4_compress_generic(
const tableType_t tableType,
const dict_directive dictDirective,
const dictIssue_directive dictIssue,
const int acceleration)
{
const int acceleration) {
DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i",
srcSize, dstCapacity);
@ -1256,8 +1252,7 @@ LZ4_FORCE_INLINE int LZ4_compress_generic(
}
int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
{
int LZ4_compress_fast_extState(void *state, const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration) {
LZ4_stream_t_internal *const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
assert(ctx != NULL);
if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
@ -1288,8 +1283,7 @@ int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int
* (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
* "correctly initialized").
*/
int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
{
int LZ4_compress_fast_extState_fastReset(void *state, const char *src, char *dst, int srcSize, int dstCapacity, int acceleration) {
LZ4_stream_t_internal *ctx = &((LZ4_stream_t *)state)->internal_donotuse;
if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
@ -1326,8 +1320,7 @@ int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst
}
int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
{
int LZ4_compress_fast(const char *source, char *dest, int inputSize, int maxOutputSize, int acceleration) {
int result;
#if (LZ4_HEAPMODE)
LZ4_stream_t *ctxPtr = ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */
@ -1345,8 +1338,7 @@ int LZ4_compress_fast(const char* source, char* dest, int inputSize, int maxOutp
}
int LZ4_compress_default(const char* src, char* dst, int srcSize, int maxOutputSize)
{
int LZ4_compress_default(const char *src, char *dst, int srcSize, int maxOutputSize) {
return LZ4_compress_fast(src, dst, srcSize, maxOutputSize, 1);
}
@ -1354,10 +1346,10 @@ int LZ4_compress_default(const char* src, char* dst, int srcSize, int maxOutputS
/* Note!: This function leaves the stream in an unclean/broken state!
* It is not safe to subsequently use the same state with a _fastReset() or
* _continue() call without resetting it. */
static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize)
{
static int LZ4_compress_destSize_extState(LZ4_stream_t *state, const char *src, char *dst, int *srcSizePtr, int targetDstSize) {
void *const s = LZ4_initStream(state, sizeof(*state));
assert(s != NULL); (void)s;
assert(s != NULL);
(void)s;
if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) { /* compression success is guaranteed */
return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, 1);
@ -1367,12 +1359,12 @@ static int LZ4_compress_destSize_extState (LZ4_stream_t* state, const char* src,
} else {
tableType_t const addrMode = ((sizeof(void *) == 4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, 1);
} }
}
}
}
int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
{
int LZ4_compress_destSize(const char *src, char *dst, int *srcSizePtr, int targetDstSize) {
#if (LZ4_HEAPMODE)
LZ4_stream_t *ctx = (LZ4_stream_t *)ALLOC(sizeof(LZ4_stream_t)); /* malloc-calloc always properly aligned */
if (ctx == NULL) return 0;
@ -1395,8 +1387,7 @@ int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targe
* Streaming functions
********************************/
LZ4_stream_t* LZ4_createStream(void)
{
LZ4_stream_t *LZ4_createStream(void) {
LZ4_stream_t *const lz4s = (LZ4_stream_t *)ALLOC(sizeof(LZ4_stream_t));
LZ4_STATIC_ASSERT(LZ4_STREAMSIZE >= sizeof(LZ4_stream_t_internal)); /* A compilation error here means LZ4_STREAMSIZE is not large enough */
DEBUGLOG(4, "LZ4_createStream %p", lz4s);
@ -1408,15 +1399,13 @@ LZ4_stream_t* LZ4_createStream(void)
#ifndef _MSC_VER /* for some reason, Visual fails the aligment test on 32-bit x86 :
it reports an aligment of 8-bytes,
while actually aligning LZ4_stream_t on 4 bytes. */
static size_t LZ4_stream_t_alignment(void)
{
static size_t LZ4_stream_t_alignment(void) {
typedef struct { char c; LZ4_stream_t t; } t_a;
return sizeof(t_a) - sizeof(LZ4_stream_t);
}
#endif
LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
{
LZ4_stream_t *LZ4_initStream(void *buffer, size_t size) {
DEBUGLOG(5, "LZ4_initStream");
if (buffer == NULL) { return NULL; }
if (size < sizeof(LZ4_stream_t)) { return NULL; }
@ -1431,8 +1420,7 @@ LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
/* resetStream is now deprecated,
* prefer initStream() which is more general */
void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
{
void LZ4_resetStream(LZ4_stream_t *LZ4_stream) {
DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t));
}
@ -1441,8 +1429,7 @@ void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
}
int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
{
int LZ4_freeStream(LZ4_stream_t *LZ4_stream) {
if (!LZ4_stream) return 0; /* support free on NULL */
DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
FREEMEM(LZ4_stream);
@ -1451,8 +1438,7 @@ int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
#define HASH_UNIT sizeof(reg_t)
int LZ4_loadDict (LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
{
int LZ4_loadDict(LZ4_stream_t *LZ4_dict, const char *dictionary, int dictSize) {
LZ4_stream_t_internal *dict = &LZ4_dict->internal_donotuse;
const tableType_t tableType = byU32;
const BYTE *p = (const BYTE *)dictionary;
@ -1521,8 +1507,7 @@ void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dict
}
static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
{
static void LZ4_renormDictT(LZ4_stream_t_internal *LZ4_dict, int nextSize) {
assert(nextSize >= 0);
if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) { /* potential ptrdiff_t overflow (32-bits mode) */
/* rescale hash table */
@ -1544,8 +1529,7 @@ static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
int LZ4_compress_fast_continue(LZ4_stream_t *LZ4_stream,
const char *source, char *dest,
int inputSize, int maxOutputSize,
int acceleration)
{
int acceleration) {
const tableType_t tableType = byU32;
LZ4_stream_t_internal *streamPtr = &LZ4_stream->internal_donotuse;
const BYTE *dictEnd = streamPtr->dictionary + streamPtr->dictSize;
@ -1566,7 +1550,8 @@ int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
}
/* Check overlapping input/dictionary space */
{ const BYTE* sourceEnd = (const BYTE*) source + inputSize;
{
const BYTE *sourceEnd = (const BYTE *) source + inputSize;
if ((sourceEnd > streamPtr->dictionary) && (sourceEnd < dictEnd)) {
streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
@ -1584,7 +1569,8 @@ int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
}
/* external dictionary mode */
{ int result;
{
int result;
if (streamPtr->dictCtx) {
/* We depend here on the fact that dictCtx'es (produced by
* LZ4_loadDict) guarantee that their tables contain no references
@ -1617,8 +1603,7 @@ int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
/* Hidden debug function, to force-test external dictionary mode */
int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
{
int LZ4_compress_forceExtDict(LZ4_stream_t *LZ4_dict, const char *source, char *dest, int srcSize) {
LZ4_stream_t_internal *streamPtr = &LZ4_dict->internal_donotuse;
int result;
@ -1644,8 +1629,7 @@ int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char*
* dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue().
* Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
*/
int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
{
int LZ4_saveDict(LZ4_stream_t *LZ4_dict, char *safeBuffer, int dictSize) {
LZ4_stream_t_internal *const dict = &LZ4_dict->internal_donotuse;
const BYTE *const previousDictEnd = dict->dictionary + dict->dictSize;
@ -1682,8 +1666,7 @@ typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;
*/
typedef enum { loop_error = -2, initial_error = -1, ok = 0 } variable_length_error;
LZ4_FORCE_INLINE unsigned
read_variable_length(const BYTE**ip, const BYTE* lencheck, int loop_check, int initial_check, variable_length_error* error)
{
read_variable_length(const BYTE **ip, const BYTE *lencheck, int loop_check, int initial_check, variable_length_error *error) {
U32 length = 0;
U32 s;
if (initial_check && unlikely((*ip) >= lencheck)) { /* overflow detection */
@ -1725,11 +1708,11 @@ LZ4_decompress_generic(
const BYTE *const lowPrefix, /* always <= dst, == dst when no prefix */
const BYTE *const dictStart, /* only if dict==usingExtDict */
const size_t dictSize /* note : = 0 if noDict */
)
{
) {
if (src == NULL) { return -1; }
{ const BYTE* ip = (const BYTE*) src;
{
const BYTE *ip = (const BYTE *) src;
const BYTE *const iend = ip + srcSize;
BYTE *op = (BYTE *) dst;
@ -1800,7 +1783,8 @@ LZ4_decompress_generic(
LZ4_wildCopy8(op, ip, cpy); /* LZ4_decompress_fast() cannot copy more than 8 bytes at a time :
* it doesn't know input length, and only relies on end-of-block properties */
}
ip += length; op = cpy;
ip += length;
op = cpy;
} else {
cpy = op + length;
if (endOnInput) { /* LZ4_decompress_safe() */
@ -1815,11 +1799,13 @@ LZ4_decompress_generic(
LZ4_memcpy(op, ip, 8);
if (length > 8) { LZ4_memcpy(op + 8, ip + 8, 8); }
}
ip += length; op = cpy;
ip += length;
op = cpy;
}
/* get offset */
offset = LZ4_readLE16(ip); ip+=2;
offset = LZ4_readLE16(ip);
ip += 2;
match = op - offset;
assert(match <= op);
@ -1854,7 +1840,9 @@ LZ4_decompress_generic(
LZ4_memcpy(op + 16, match + 16, 2);
op += length;
continue;
} } }
}
}
}
if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) { goto _output_error; } /* Error : offset outside buffers */
/* match starting within external dictionary */
@ -1865,7 +1853,8 @@ LZ4_decompress_generic(
length = MIN(length, (size_t)(oend - op));
} else {
goto _output_error; /* end-of-block condition violated */
} }
}
}
if (length <= (size_t)(lowPrefix - match)) {
/* match fits entirely within external dictionary : just copy */
@ -1884,7 +1873,8 @@ LZ4_decompress_generic(
} else {
LZ4_memcpy(op, lowPrefix, restSize);
op += restSize;
} }
}
}
continue;
}
@ -1924,12 +1914,14 @@ LZ4_decompress_generic(
&& likely((endOnInput ? ip < shortiend : 1) & (op <= shortoend))) {
/* Copy the literals */
LZ4_memcpy(op, ip, endOnInput ? 16 : 8);
op += length; ip += length;
op += length;
ip += length;
/* The second stage: prepare for match copying, decode full info.
* If it doesn't work out, the info won't be wasted. */
length = token & ML_MASK; /* match length */
offset = LZ4_readLE16(ip); ip += 2;
offset = LZ4_readLE16(ip);
ip += 2;
match = op - offset;
assert(match <= op); /* check overflow */
@ -1967,8 +1959,7 @@ LZ4_decompress_generic(
#endif
LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
if (((endOnInput) && ((cpy > oend - MFLIMIT) || (ip + length > iend - (2 + 1 + LASTLITERALS))))
|| ((!endOnInput) && (cpy>oend-WILDCOPYLENGTH)) )
{
|| ((!endOnInput) && (cpy > oend - WILDCOPYLENGTH))) {
/* We've either hit the input parsing restriction or the output parsing restriction.
* In the normal scenario, decoding a full block, it must be the last sequence,
* otherwise it's an error (invalid input or dimensions).
@ -2021,11 +2012,13 @@ LZ4_decompress_generic(
}
} else {
LZ4_wildCopy8(op, ip, cpy); /* may overwrite up to WILDCOPYLENGTH beyond cpy */
ip += length; op = cpy;
ip += length;
op = cpy;
}
/* get offset */
offset = LZ4_readLE16(ip); ip+=2;
offset = LZ4_readLE16(ip);
ip += 2;
match = op - offset;
/* get matchlength */
@ -2068,7 +2061,8 @@ LZ4_decompress_generic(
} else {
LZ4_memcpy(op, lowPrefix, restSize);
op += restSize;
} }
}
}
continue;
}
assert(match >= lowPrefix);
@ -2141,16 +2135,14 @@ LZ4_decompress_generic(
/*===== Instantiate the API decoding functions. =====*/
LZ4_FORCE_O2_GCC_PPC64LE
int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
{
int LZ4_decompress_safe(const char *source, char *dest, int compressedSize, int maxDecompressedSize) {
return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
endOnInputSize, decode_full_block, noDict,
(BYTE *)dest, NULL, 0);
}
LZ4_FORCE_O2_GCC_PPC64LE
int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity)
{
int LZ4_decompress_safe_partial(const char *src, char *dst, int compressedSize, int targetOutputSize, int dstCapacity) {
dstCapacity = MIN(targetOutputSize, dstCapacity);
return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,
endOnInputSize, partial_decode,
@ -2158,8 +2150,7 @@ int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize,
}
LZ4_FORCE_O2_GCC_PPC64LE
int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
{
int LZ4_decompress_fast(const char *source, char *dest, int originalSize) {
return LZ4_decompress_generic(source, dest, 0, originalSize,
endOnOutputSize, decode_full_block, withPrefix64k,
(BYTE *)dest - 64 KB, NULL, 0);
@ -2168,16 +2159,14 @@ int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
/*===== Instantiate a few more decoding cases, used more than once. =====*/
LZ4_FORCE_O2_GCC_PPC64LE /* Exported, an obsolete API function. */
int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
{
int LZ4_decompress_safe_withPrefix64k(const char *source, char *dest, int compressedSize, int maxOutputSize) {
return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
endOnInputSize, decode_full_block, withPrefix64k,
(BYTE *)dest - 64 KB, NULL, 0);
}
/* Another obsolete API function, paired with the previous one. */
int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
{
int LZ4_decompress_fast_withPrefix64k(const char *source, char *dest, int originalSize) {
/* LZ4_decompress_fast doesn't validate match offsets,
* and thus serves well with any prefixed dictionary. */
return LZ4_decompress_fast(source, dest, originalSize);
@ -2185,8 +2174,7 @@ int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int origin
LZ4_FORCE_O2_GCC_PPC64LE
static int LZ4_decompress_safe_withSmallPrefix(const char *source, char *dest, int compressedSize, int maxOutputSize,
size_t prefixSize)
{
size_t prefixSize) {
return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
endOnInputSize, decode_full_block, noDict,
(BYTE *)dest - prefixSize, NULL, 0);
@ -2195,8 +2183,7 @@ static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, i
LZ4_FORCE_O2_GCC_PPC64LE
int LZ4_decompress_safe_forceExtDict(const char *source, char *dest,
int compressedSize, int maxOutputSize,
const void* dictStart, size_t dictSize)
{
const void *dictStart, size_t dictSize) {
return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
endOnInputSize, decode_full_block, usingExtDict,
(BYTE *)dest, (const BYTE *)dictStart, dictSize);
@ -2204,8 +2191,7 @@ int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
LZ4_FORCE_O2_GCC_PPC64LE
static int LZ4_decompress_fast_extDict(const char *source, char *dest, int originalSize,
const void* dictStart, size_t dictSize)
{
const void *dictStart, size_t dictSize) {
return LZ4_decompress_generic(source, dest, 0, originalSize,
endOnOutputSize, decode_full_block, usingExtDict,
(BYTE *)dest, (const BYTE *)dictStart, dictSize);
@ -2217,8 +2203,7 @@ static int LZ4_decompress_fast_extDict(const char* source, char* dest, int origi
*/
LZ4_FORCE_INLINE
int LZ4_decompress_safe_doubleDict(const char *source, char *dest, int compressedSize, int maxOutputSize,
size_t prefixSize, const void* dictStart, size_t dictSize)
{
size_t prefixSize, const void *dictStart, size_t dictSize) {
return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
endOnInputSize, decode_full_block, usingExtDict,
(BYTE *)dest - prefixSize, (const BYTE *)dictStart, dictSize);
@ -2226,8 +2211,7 @@ int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compresse
LZ4_FORCE_INLINE
int LZ4_decompress_fast_doubleDict(const char *source, char *dest, int originalSize,
size_t prefixSize, const void* dictStart, size_t dictSize)
{
size_t prefixSize, const void *dictStart, size_t dictSize) {
return LZ4_decompress_generic(source, dest, 0, originalSize,
endOnOutputSize, decode_full_block, usingExtDict,
(BYTE *)dest - prefixSize, (const BYTE *)dictStart, dictSize);
@ -2235,15 +2219,13 @@ int LZ4_decompress_fast_doubleDict(const char* source, char* dest, int originalS
/*===== streaming decompression functions =====*/
LZ4_streamDecode_t* LZ4_createStreamDecode(void)
{
LZ4_streamDecode_t *LZ4_createStreamDecode(void) {
LZ4_streamDecode_t *lz4s = (LZ4_streamDecode_t *) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
LZ4_STATIC_ASSERT(LZ4_STREAMDECODESIZE >= sizeof(LZ4_streamDecode_t_internal)); /* A compilation error here means LZ4_STREAMDECODESIZE is not large enough */
return lz4s;
}
int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
{
int LZ4_freeStreamDecode(LZ4_streamDecode_t *LZ4_stream) {
if (LZ4_stream == NULL) { return 0; } /* support free on NULL */
FREEMEM(LZ4_stream);
return 0;
@ -2255,8 +2237,7 @@ int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
* Loading a size of 0 is allowed (same effect as no dictionary).
* @return : 1 if OK, 0 if error
*/
int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
{
int LZ4_setStreamDecode(LZ4_streamDecode_t *LZ4_streamDecode, const char *dictionary, int dictSize) {
LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse;
lz4sd->prefixSize = (size_t) dictSize;
lz4sd->prefixEnd = (const BYTE *) dictionary + dictSize;
@ -2276,8 +2257,7 @@ int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dicti
* @return : minimum ring buffer size,
* or 0 if there is an error (invalid maxBlockSize).
*/
int LZ4_decoderRingBufferSize(int maxBlockSize)
{
int LZ4_decoderRingBufferSize(int maxBlockSize) {
if (maxBlockSize < 0) return 0;
if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
if (maxBlockSize < 16) maxBlockSize = 16;
@ -2292,8 +2272,7 @@ int LZ4_decoderRingBufferSize(int maxBlockSize)
and indicate where it stands using LZ4_setStreamDecode()
*/
LZ4_FORCE_O2_GCC_PPC64LE
int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
{
int LZ4_decompress_safe_continue(LZ4_streamDecode_t *LZ4_streamDecode, const char *source, char *dest, int compressedSize, int maxOutputSize) {
LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse;
int result;
@ -2332,8 +2311,7 @@ int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const ch
}
LZ4_FORCE_O2_GCC_PPC64LE
int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize)
{
int LZ4_decompress_fast_continue(LZ4_streamDecode_t *LZ4_streamDecode, const char *source, char *dest, int originalSize) {
LZ4_streamDecode_t_internal *lz4sd = &LZ4_streamDecode->internal_donotuse;
int result;
assert(originalSize >= 0);
@ -2374,8 +2352,7 @@ Advanced decoding functions :
the dictionary must be explicitly provided within parameters
*/
int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
{
int LZ4_decompress_safe_usingDict(const char *source, char *dest, int compressedSize, int maxOutputSize, const char *dictStart, int dictSize) {
if (dictSize == 0)
return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
if (dictStart + dictSize == dest) {
@ -2389,8 +2366,7 @@ int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressed
return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
}
int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
{
int LZ4_decompress_fast_usingDict(const char *source, char *dest, int originalSize, const char *dictStart, int dictSize) {
if (dictSize == 0 || dictStart + dictSize == dest)
return LZ4_decompress_fast(source, dest, originalSize);
assert(dictSize >= 0);
@ -2402,28 +2378,22 @@ int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSi
* Obsolete Functions
***************************************************/
/* obsolete compression functions */
int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
{
int LZ4_compress_limitedOutput(const char *source, char *dest, int inputSize, int maxOutputSize) {
return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
}
int LZ4_compress(const char* src, char* dest, int srcSize)
{
int LZ4_compress(const char *src, char *dest, int srcSize) {
return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize));
}
int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize)
{
int LZ4_compress_limitedOutput_withState(void *state, const char *src, char *dst, int srcSize, int dstSize) {
return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
}
int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize)
{
int LZ4_compress_withState(void *state, const char *src, char *dst, int srcSize) {
return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
}
int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity)
{
int LZ4_compress_limitedOutput_continue(LZ4_stream_t *LZ4_stream, const char *src, char *dst, int srcSize, int dstCapacity) {
return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
}
int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize)
{
int LZ4_compress_continue(LZ4_stream_t *LZ4_stream, const char *source, char *dest, int inputSize) {
return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
}
@ -2433,12 +2403,10 @@ They are only provided here for compatibility with older user programs.
- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
*/
int LZ4_uncompress (const char* source, char* dest, int outputSize)
{
int LZ4_uncompress(const char *source, char *dest, int outputSize) {
return LZ4_decompress_fast(source, dest, outputSize);
}
int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize)
{
int LZ4_uncompress_unknownOutputSize(const char *source, char *dest, int isize, int maxOutputSize) {
return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
}
@ -2446,21 +2414,18 @@ int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize,
int LZ4_sizeofStreamState(void) { return LZ4_STREAMSIZE; }
int LZ4_resetStreamState(void* state, char* inputBuffer)
{
int LZ4_resetStreamState(void *state, char *inputBuffer) {
(void)inputBuffer;
LZ4_resetStream((LZ4_stream_t *)state);
return 0;
}
void* LZ4_create (char* inputBuffer)
{
void *LZ4_create(char *inputBuffer) {
(void)inputBuffer;
return LZ4_createStream();
}
char* LZ4_slideInputBuffer (void* state)
{
char *LZ4_slideInputBuffer(void *state) {
/* avoid const char * -> char * conversion warning */
return (char *)(uptrval)((LZ4_stream_t *)state)->internal_donotuse.dictionary;
}

289
common/lz4/lz4hc.c
View file

@ -90,14 +90,12 @@ static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)
/**************************************
* HC Compression
**************************************/
static void LZ4HC_clearTables (LZ4HC_CCtx_internal* hc4)
{
static void LZ4HC_clearTables(LZ4HC_CCtx_internal *hc4) {
MEM_INIT((void *)hc4->hashTable, 0, sizeof(hc4->hashTable));
MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));
}
static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)
{
static void LZ4HC_init_internal(LZ4HC_CCtx_internal *hc4, const BYTE *start) {
uptrval startingOffset = (uptrval)(hc4->end - hc4->base);
if (startingOffset > 1 GB) {
LZ4HC_clearTables(hc4);
@ -114,8 +112,7 @@ static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)
/* Update chains up to ip (excluded) */
LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)
{
LZ4_FORCE_INLINE void LZ4HC_Insert(LZ4HC_CCtx_internal *hc4, const BYTE *ip) {
U16 *const chainTable = hc4->chainTable;
U32 *const hashTable = hc4->hashTable;
const BYTE *const base = hc4->base;
@ -138,13 +135,14 @@ LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)
* @return : negative value, nb of common bytes before ip/match */
LZ4_FORCE_INLINE
int LZ4HC_countBack(const BYTE *const ip, const BYTE *const match,
const BYTE* const iMin, const BYTE* const mMin)
{
const BYTE *const iMin, const BYTE *const mMin) {
int back = 0;
int const min = (int)MAX(iMin - ip, mMin - match);
assert(min <= 0);
assert(ip >= iMin); assert((size_t)(ip-iMin) < (1U<<31));
assert(match >= mMin); assert((size_t)(match - mMin) < (1U<<31));
assert(ip >= iMin);
assert((size_t)(ip - iMin) < (1U << 31));
assert(match >= mMin);
assert((size_t)(match - mMin) < (1U << 31));
while ((back > min)
&& (ip[back - 1] == match[back - 1]))
back--;
@ -158,8 +156,7 @@ int LZ4HC_countBack(const BYTE* const ip, const BYTE* const match,
#endif
static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern)
{
static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern) {
size_t const bitsToRotate = (rotate & (sizeof(pattern) - 1)) << 3;
if (bitsToRotate == 0)
return pattern;
@ -169,8 +166,7 @@ static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern)
/* LZ4HC_countPattern() :
* pattern32 must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) */
static unsigned
LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)
{
LZ4HC_countPattern(const BYTE *ip, const BYTE *const iEnd, U32 const pattern32) {
const BYTE *const iStart = ip;
reg_t const pattern = (sizeof(pattern) == 8) ? (reg_t)pattern32 + (((reg_t)pattern32) << 32) : pattern32;
@ -184,14 +180,16 @@ LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)
if (LZ4_isLittleEndian()) {
reg_t patternByte = pattern;
while ((ip < iEnd) && (*ip == (BYTE)patternByte)) {
ip++; patternByte >>= 8;
ip++;
patternByte >>= 8;
}
} else { /* big endian */
U32 bitOffset = (sizeof(pattern) * 8) - 8;
while (ip < iEnd) {
BYTE const byte = (BYTE)(pattern >> bitOffset);
if (*ip != byte) break;
ip ++; bitOffset -= 8;
ip ++;
bitOffset -= 8;
}
}
@ -202,19 +200,21 @@ LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)
* pattern must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!)
* read using natural platform endianess */
static unsigned
LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern)
{
LZ4HC_reverseCountPattern(const BYTE *ip, const BYTE *const iLow, U32 pattern) {
const BYTE *const iStart = ip;
while (likely(ip >= iLow + 4)) {
if (LZ4_read32(ip - 4) != pattern) break;
ip -= 4;
}
{ const BYTE* bytePtr = (const BYTE*)(&pattern) + 3; /* works for any endianess */
{
const BYTE *bytePtr = (const BYTE *)(&pattern) + 3; /* works for any endianess */
while (likely(ip > iLow)) {
if (ip[-1] != *bytePtr) break;
ip--; bytePtr--;
} }
ip--;
bytePtr--;
}
}
return (unsigned)(iStart - ip);
}
@ -223,8 +223,7 @@ LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern)
* 4 byte MINMATCH would overflow.
* @returns true if the match index is okay.
*/
static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex)
{
static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex) {
return ((U32)((dictLimit - 1) - matchIndex) >= 3);
}
@ -244,8 +243,7 @@ LZ4HC_InsertAndGetWiderMatch (
const int patternAnalysis,
const int chainSwap,
const dictCtx_directive dict,
const HCfavor_e favorDecSpeed)
{
const HCfavor_e favorDecSpeed) {
U16 *const chainTable = hc4->chainTable;
U32 *const HashTable = hc4->hashTable;
const LZ4HC_CCtx_internal *const dictCtx = hc4->dictCtx;
@ -290,7 +288,9 @@ LZ4HC_InsertAndGetWiderMatch (
longest = matchLength;
*matchpos = matchPtr + back;
*startpos = ip + back;
} } }
}
}
}
} else { /* lowestMatchIndex <= matchIndex < dictLimit */
const BYTE *const matchPtr = dictBase + matchIndex;
if (LZ4_read32(matchPtr) == pattern) {
@ -307,7 +307,9 @@ LZ4HC_InsertAndGetWiderMatch (
longest = matchLength;
*matchpos = base + matchIndex + back; /* virtual pos, relative to ip, to retrieve offset */
*startpos = ip + back;
} } }
}
}
}
if (chainSwap && matchLength == longest) { /* better match => select a better chain */
assert(lookBackLength == 0); /* search forward only */
@ -331,9 +333,12 @@ LZ4HC_InsertAndGetWiderMatch (
if (distanceToNextMatch > matchIndex) break; /* avoid overflow */
matchIndex -= distanceToNextMatch;
continue;
} } }
}
}
}
{ U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex);
{
U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex);
if (patternAnalysis && distNextMatch == 1 && matchChainPos == 0) {
U32 const matchCandidateIdx = matchIndex - 1;
/* may be a repeated pattern */
@ -344,7 +349,8 @@ LZ4HC_InsertAndGetWiderMatch (
srcPatternLength = LZ4HC_countPattern(ip + sizeof(pattern), iHighLimit, pattern) + sizeof(pattern);
} else {
repeat = rep_not;
} }
}
}
if ((repeat == rep_confirmed) && (matchCandidateIdx >= lowestMatchIndex)
&& LZ4HC_protectDictEnd(dictLimit, matchCandidateIdx)) {
const int extDict = matchCandidateIdx < dictLimit;
@ -357,7 +363,8 @@ LZ4HC_InsertAndGetWiderMatch (
U32 const rotatedPattern = LZ4HC_rotatePattern(forwardPatternLength, pattern);
forwardPatternLength += LZ4HC_countPattern(lowPrefixPtr, iHighLimit, rotatedPattern);
}
{ const BYTE* const lowestMatchPtr = extDict ? dictStart : lowPrefixPtr;
{
const BYTE *const lowestMatchPtr = extDict ? dictStart : lowPrefixPtr;
size_t backLength = LZ4HC_reverseCountPattern(matchPtr, lowestMatchPtr, pattern);
size_t currentSegmentLength;
if (!extDict && matchPtr - backLength == lowPrefixPtr && hc4->lowLimit < dictLimit) {
@ -396,13 +403,20 @@ LZ4HC_InsertAndGetWiderMatch (
*matchpos = base + matchIndex; /* virtual pos, relative to ip, to retrieve offset */
*startpos = ip;
}
{ U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex);
{
U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex);
if (distToNextPattern > matchIndex) break; /* avoid overflow */
matchIndex -= distToNextPattern;
} } } } }
}
}
}
}
}
continue;
} }
} } /* PA optimization */
}
}
}
} /* PA optimization */
/* follow current chain */
matchIndex -= DELTANEXTU16(chainTable, matchIndex + matchChainPos);
@ -431,12 +445,16 @@ LZ4HC_InsertAndGetWiderMatch (
longest = mlt;
*matchpos = base + matchIndex + back;
*startpos = ip + back;
} }
}
}
{ U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex);
{
U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex);
dictMatchIndex -= nextOffset;
matchIndex -= nextOffset;
} } }
}
}
}
return longest;
}
@ -447,8 +465,7 @@ int LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4, /* Index tabl
const BYTE **matchpos,
const int maxNbAttempts,
const int patternAnalysis,
const dictCtx_directive dict)
{
const dictCtx_directive dict) {
const BYTE *uselessPtr = ip;
/* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
* but this won't be the case here, as we define iLowLimit==ip,
@ -466,8 +483,7 @@ LZ4_FORCE_INLINE int LZ4HC_encodeSequence (
int matchLength,
const BYTE *const match,
limitedOutput_directive limit,
BYTE* oend)
{
BYTE *oend) {
size_t length;
BYTE *const token = (*op)++;
@ -506,7 +522,8 @@ LZ4_FORCE_INLINE int LZ4HC_encodeSequence (
/* Encode Offset */
assert((*ip - match) <= LZ4_DISTANCE_MAX); /* note : consider providing offset as a value, rather than as a pointer difference */
LZ4_writeLE16(*op, (U16)(*ip-match)); *op += 2;
LZ4_writeLE16(*op, (U16)(*ip - match));
*op += 2;
/* Encode MatchLength */
assert(matchLength >= MINMATCH);
@ -538,8 +555,7 @@ LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
unsigned maxNbAttempts,
const limitedOutput_directive limit,
const dictCtx_directive dict
)
{
) {
const int inputSize = *srcSizePtr;
const int patternAnalysis = (maxNbAttempts > 128); /* levels 9+ */
@ -573,7 +589,9 @@ LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
if (ml < MINMATCH) { ip++; continue; }
/* saved, in case we would skip too much */
start0 = ip; ref0 = ref; ml0 = ml;
start0 = ip;
ref0 = ref;
ml0 = ml;
_Search2:
if (ip + ml <= mflimit) {
@ -592,8 +610,11 @@ _Search2:
if (start0 < ip) { /* first match was skipped at least once */
if (start2 < ip + ml0) { /* squeezing ML1 between ML0(original ML1) and ML2 */
ip = start0; ref = ref0; ml = ml0; /* restore initial ML1 */
} }
ip = start0;
ref = ref0;
ml = ml0; /* restore initial ML1 */
}
}
/* Here, start0==ip */
if ((start2 - ip) < 3) { /* First Match too small : removed */
@ -697,10 +718,14 @@ _Search3:
if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ref, limit, oend)) goto _dest_overflow;
/* ML2 becomes ML1 */
ip = start2; ref = ref2; ml = ml2;
ip = start2;
ref = ref2;
ml = ml2;
/* ML3 becomes ML2 */
start2 = start3; ref2 = ref3; ml2 = ml3;
start2 = start3;
ref2 = ref3;
ml2 = ml3;
/* let's find a new ML3 */
goto _Search3;
@ -708,7 +733,8 @@ _Search3:
_last_literals:
/* Encode Last Literals */
{ size_t lastRunSize = (size_t)(iend - anchor); /* literals */
{
size_t lastRunSize = (size_t)(iend - anchor); /* literals */
size_t litLength = (lastRunSize + 255 - RUN_MASK) / 255;
size_t const totalSize = 1 + litLength + lastRunSize;
if (limit == fillOutput) oend += LASTLITERALS; /* restore correct value */
@ -764,8 +790,7 @@ LZ4_FORCE_INLINE int LZ4HC_compress_generic_internal (
int cLevel,
const limitedOutput_directive limit,
const dictCtx_directive dict
)
{
) {
typedef enum { lz4hc, lz4opt } lz4hc_strat_e;
typedef struct {
lz4hc_strat_e strat;
@ -796,7 +821,8 @@ LZ4_FORCE_INLINE int LZ4HC_compress_generic_internal (
ctx->end += *srcSizePtr;
if (cLevel < 1) cLevel = LZ4HC_CLEVEL_DEFAULT; /* note : convention is different from lz4frame, maybe something to review */
cLevel = MIN(LZ4HC_CLEVEL_MAX, cLevel);
{ cParams_t const cParam = clTable[cLevel];
{
cParams_t const cParam = clTable[cLevel];
HCfavor_e const favor = ctx->favorDecSpeed ? favorDecompressionSpeed : favorCompressionRatio;
int result;
@ -828,8 +854,7 @@ LZ4HC_compress_generic_noDictCtx (
int const dstCapacity,
int cLevel,
limitedOutput_directive limit
)
{
) {
assert(ctx->dictCtx == NULL);
return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, noDictCtx);
}
@ -843,8 +868,7 @@ LZ4HC_compress_generic_dictCtx (
int const dstCapacity,
int cLevel,
limitedOutput_directive limit
)
{
) {
const size_t position = (size_t)(ctx->end - ctx->base) - ctx->lowLimit;
assert(ctx->dictCtx != NULL);
if (position >= 64 KB) {
@ -869,8 +893,7 @@ LZ4HC_compress_generic (
int const dstCapacity,
int cLevel,
limitedOutput_directive limit
)
{
) {
if (ctx->dictCtx == NULL) {
return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
} else {
@ -884,8 +907,7 @@ int LZ4_sizeofStateHC(void) { return (int)sizeof(LZ4_streamHC_t); }
#ifndef _MSC_VER /* for some reason, Visual fails the aligment test on 32-bit x86 :
* it reports an aligment of 8-bytes,
* while actually aligning LZ4_streamHC_t on 4 bytes. */
static size_t LZ4_streamHC_t_alignment(void)
{
static size_t LZ4_streamHC_t_alignment(void) {
typedef struct { char c; LZ4_streamHC_t t; } t_a;
return sizeof(t_a) - sizeof(LZ4_streamHC_t);
}
@ -893,8 +915,7 @@ static size_t LZ4_streamHC_t_alignment(void)
/* state is presumed correctly initialized,
* in which case its size and alignment have already been validate */
int LZ4_compress_HC_extStateHC_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
{
int LZ4_compress_HC_extStateHC_fastReset(void *state, const char *src, char *dst, int srcSize, int dstCapacity, int compressionLevel) {
LZ4HC_CCtx_internal *const ctx = &((LZ4_streamHC_t *)state)->internal_donotuse;
#ifndef _MSC_VER /* for some reason, Visual fails the aligment test on 32-bit x86 :
* it reports an aligment of 8-bytes,
@ -910,15 +931,13 @@ int LZ4_compress_HC_extStateHC_fastReset (void* state, const char* src, char* ds
return LZ4HC_compress_generic(ctx, src, dst, &srcSize, dstCapacity, compressionLevel, notLimited);
}
int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
{
int LZ4_compress_HC_extStateHC(void *state, const char *src, char *dst, int srcSize, int dstCapacity, int compressionLevel) {
LZ4_streamHC_t *const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
if (ctx == NULL) return 0; /* init failure */
return LZ4_compress_HC_extStateHC_fastReset(state, src, dst, srcSize, dstCapacity, compressionLevel);
}
int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
{
int LZ4_compress_HC(const char *src, char *dst, int srcSize, int dstCapacity, int compressionLevel) {
#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
LZ4_streamHC_t *const statePtr = (LZ4_streamHC_t *)ALLOC(sizeof(LZ4_streamHC_t));
#else
@ -933,8 +952,7 @@ int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, in
}
/* state is presumed sized correctly (>= sizeof(LZ4_streamHC_t)) */
int LZ4_compress_HC_destSize(void* state, const char* source, char* dest, int* sourceSizePtr, int targetDestSize, int cLevel)
{
int LZ4_compress_HC_destSize(void *state, const char *source, char *dest, int *sourceSizePtr, int targetDestSize, int cLevel) {
LZ4_streamHC_t *const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
if (ctx == NULL) return 0; /* init failure */
LZ4HC_init_internal(&ctx->internal_donotuse, (const BYTE *) source);
@ -948,16 +966,14 @@ int LZ4_compress_HC_destSize(void* state, const char* source, char* dest, int* s
* Streaming Functions
**************************************/
/* allocation */
LZ4_streamHC_t* LZ4_createStreamHC(void)
{
LZ4_streamHC_t *LZ4_createStreamHC(void) {
LZ4_streamHC_t *const LZ4_streamHCPtr = (LZ4_streamHC_t *)ALLOC(sizeof(LZ4_streamHC_t));
if (LZ4_streamHCPtr == NULL) return NULL;
LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr)); /* full initialization, malloc'ed buffer can be full of garbage */
return LZ4_streamHCPtr;
}
int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr)
{
int LZ4_freeStreamHC(LZ4_streamHC_t *LZ4_streamHCPtr) {
DEBUGLOG(4, "LZ4_freeStreamHC(%p)", LZ4_streamHCPtr);
if (!LZ4_streamHCPtr) return 0; /* support free on NULL */
FREEMEM(LZ4_streamHCPtr);
@ -965,8 +981,7 @@ int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr)
}
LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size)
{
LZ4_streamHC_t *LZ4_initStreamHC(void *buffer, size_t size) {
LZ4_streamHC_t *const LZ4_streamHCPtr = (LZ4_streamHC_t *)buffer;
if (buffer == NULL) return NULL;
if (size < sizeof(LZ4_streamHC_t)) return NULL;
@ -989,14 +1004,12 @@ LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size)
}
/* just a stub */
void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
{
void LZ4_resetStreamHC(LZ4_streamHC_t *LZ4_streamHCPtr, int compressionLevel) {
LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
}
void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
{
void LZ4_resetStreamHC_fast(LZ4_streamHC_t *LZ4_streamHCPtr, int compressionLevel) {
DEBUGLOG(4, "LZ4_resetStreamHC_fast(%p, %d)", LZ4_streamHCPtr, compressionLevel);
if (LZ4_streamHCPtr->internal_donotuse.dirty) {
LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
@ -1009,24 +1022,21 @@ void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLev
LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
}
void LZ4_setCompressionLevel(LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
{
void LZ4_setCompressionLevel(LZ4_streamHC_t *LZ4_streamHCPtr, int compressionLevel) {
DEBUGLOG(5, "LZ4_setCompressionLevel(%p, %d)", LZ4_streamHCPtr, compressionLevel);
if (compressionLevel < 1) compressionLevel = LZ4HC_CLEVEL_DEFAULT;
if (compressionLevel > LZ4HC_CLEVEL_MAX) compressionLevel = LZ4HC_CLEVEL_MAX;
LZ4_streamHCPtr->internal_donotuse.compressionLevel = (short)compressionLevel;
}
void LZ4_favorDecompressionSpeed(LZ4_streamHC_t* LZ4_streamHCPtr, int favor)
{
void LZ4_favorDecompressionSpeed(LZ4_streamHC_t *LZ4_streamHCPtr, int favor) {
LZ4_streamHCPtr->internal_donotuse.favorDecSpeed = (favor != 0);
}
/* LZ4_loadDictHC() :
* LZ4_streamHCPtr is presumed properly initialized */
int LZ4_loadDictHC(LZ4_streamHC_t *LZ4_streamHCPtr,
const char* dictionary, int dictSize)
{
const char *dictionary, int dictSize) {
LZ4HC_CCtx_internal *const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
DEBUGLOG(4, "LZ4_loadDictHC(ctx:%p, dict:%p, dictSize:%d)", LZ4_streamHCPtr, dictionary, dictSize);
assert(LZ4_streamHCPtr != NULL);
@ -1035,7 +1045,8 @@ int LZ4_loadDictHC (LZ4_streamHC_t* LZ4_streamHCPtr,
dictSize = 64 KB;
}
/* need a full initialization, there are bad side-effects when using resetFast() */
{ int const cLevel = ctxPtr->compressionLevel;
{
int const cLevel = ctxPtr->compressionLevel;
LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
LZ4_setCompressionLevel(LZ4_streamHCPtr, cLevel);
}
@ -1051,8 +1062,7 @@ void LZ4_attach_HC_dictionary(LZ4_streamHC_t *working_stream, const LZ4_streamHC
/* compression */
static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock)
{
static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal *ctxPtr, const BYTE *newBlock) {
DEBUGLOG(4, "LZ4HC_setExternalDict(%p, %p)", ctxPtr, newBlock);
if (ctxPtr->end >= ctxPtr->base + ctxPtr->dictLimit + 4)
LZ4HC_Insert(ctxPtr, ctxPtr->end - 3); /* Referencing remaining dictionary content */
@ -1072,8 +1082,7 @@ static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBl
static int LZ4_compressHC_continue_generic(LZ4_streamHC_t *LZ4_streamHCPtr,
const char *src, char *dst,
int *srcSizePtr, int dstCapacity,
limitedOutput_directive limit)
{
limitedOutput_directive limit) {
LZ4HC_CCtx_internal *const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
DEBUGLOG(4, "LZ4_compressHC_continue_generic(ctx=%p, src=%p, srcSize=%d)",
LZ4_streamHCPtr, src, *srcSizePtr);
@ -1093,7 +1102,8 @@ static int LZ4_compressHC_continue_generic (LZ4_streamHC_t* LZ4_streamHCPtr,
LZ4HC_setExternalDict(ctxPtr, (const BYTE *)src);
/* Check overlapping input/dictionary space */
{ const BYTE* sourceEnd = (const BYTE*) src + *srcSizePtr;
{
const BYTE *sourceEnd = (const BYTE *) src + *srcSizePtr;
const BYTE *const dictBegin = ctxPtr->dictBase + ctxPtr->lowLimit;
const BYTE *const dictEnd = ctxPtr->dictBase + ctxPtr->dictLimit;
if ((sourceEnd > dictBegin) && ((const BYTE *)src < dictEnd)) {
@ -1106,16 +1116,14 @@ static int LZ4_compressHC_continue_generic (LZ4_streamHC_t* LZ4_streamHCPtr,
return LZ4HC_compress_generic(ctxPtr, src, dst, srcSizePtr, dstCapacity, ctxPtr->compressionLevel, limit);
}
int LZ4_compress_HC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int srcSize, int dstCapacity)
{
int LZ4_compress_HC_continue(LZ4_streamHC_t *LZ4_streamHCPtr, const char *src, char *dst, int srcSize, int dstCapacity) {
if (dstCapacity < LZ4_compressBound(srcSize))
return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, limitedOutput);
else
return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, notLimited);
}
int LZ4_compress_HC_continue_destSize (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int* srcSizePtr, int targetDestSize)
{
int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t *LZ4_streamHCPtr, const char *src, char *dst, int *srcSizePtr, int targetDestSize) {
return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, srcSizePtr, targetDestSize, fillOutput);
}
@ -1123,8 +1131,7 @@ int LZ4_compress_HC_continue_destSize (LZ4_streamHC_t* LZ4_streamHCPtr, const ch
/* dictionary saving */
int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictSize)
{
int LZ4_saveDictHC(LZ4_streamHC_t *LZ4_streamHCPtr, char *safeBuffer, int dictSize) {
LZ4HC_CCtx_internal *const streamPtr = &LZ4_streamHCPtr->internal_donotuse;
int const prefixSize = (int)(streamPtr->end - (streamPtr->base + streamPtr->dictLimit));
DEBUGLOG(4, "LZ4_saveDictHC(%p, %p, %d)", LZ4_streamHCPtr, safeBuffer, dictSize);
@ -1132,7 +1139,8 @@ int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictS
if (dictSize < 4) dictSize = 0;
if (dictSize > prefixSize) dictSize = prefixSize;
memmove(safeBuffer, streamPtr->end - dictSize, dictSize);
{ U32 const endIndex = (U32)(streamPtr->end - streamPtr->base);
{
U32 const endIndex = (U32)(streamPtr->end - streamPtr->base);
streamPtr->end = (const BYTE *)safeBuffer + dictSize;
streamPtr->base = streamPtr->end - endIndex;
streamPtr->dictLimit = endIndex - (U32)dictSize;
@ -1167,41 +1175,35 @@ int LZ4_sizeofStreamStateHC(void) { return LZ4_STREAMHCSIZE; }
/* state is presumed correctly sized, aka >= sizeof(LZ4_streamHC_t)
* @return : 0 on success, !=0 if error */
int LZ4_resetStreamStateHC(void* state, char* inputBuffer)
{
int LZ4_resetStreamStateHC(void *state, char *inputBuffer) {
LZ4_streamHC_t *const hc4 = LZ4_initStreamHC(state, sizeof(*hc4));
if (hc4 == NULL) return 1; /* init failed */
LZ4HC_init_internal(&hc4->internal_donotuse, (const BYTE *)inputBuffer);
return 0;
}
void* LZ4_createHC (const char* inputBuffer)
{
void *LZ4_createHC(const char *inputBuffer) {
LZ4_streamHC_t *const hc4 = LZ4_createStreamHC();
if (hc4 == NULL) return NULL; /* not enough memory */
LZ4HC_init_internal(&hc4->internal_donotuse, (const BYTE *)inputBuffer);
return hc4;
}
int LZ4_freeHC (void* LZ4HC_Data)
{
int LZ4_freeHC(void *LZ4HC_Data) {
if (!LZ4HC_Data) return 0; /* support free on NULL */
FREEMEM(LZ4HC_Data);
return 0;
}
int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int cLevel)
{
int LZ4_compressHC2_continue(void *LZ4HC_Data, const char *src, char *dst, int srcSize, int cLevel) {
return LZ4HC_compress_generic(&((LZ4_streamHC_t *)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, 0, cLevel, notLimited);
}
int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int dstCapacity, int cLevel)
{
int LZ4_compressHC2_limitedOutput_continue(void *LZ4HC_Data, const char *src, char *dst, int srcSize, int dstCapacity, int cLevel) {
return LZ4HC_compress_generic(&((LZ4_streamHC_t *)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, dstCapacity, cLevel, limitedOutput);
}
char* LZ4_slideInputBufferHC(void* LZ4HC_Data)
{
char *LZ4_slideInputBufferHC(void *LZ4HC_Data) {
LZ4_streamHC_t *ctx = (LZ4_streamHC_t *)LZ4HC_Data;
const BYTE *bufferStart = ctx->internal_donotuse.base + ctx->internal_donotuse.lowLimit;
LZ4_resetStreamHC_fast(ctx, ctx->internal_donotuse.compressionLevel);
@ -1221,8 +1223,7 @@ typedef struct {
} LZ4HC_optimal_t;
/* price in bytes */
LZ4_FORCE_INLINE int LZ4HC_literalsPrice(int const litlen)
{
LZ4_FORCE_INLINE int LZ4HC_literalsPrice(int const litlen) {
int price = litlen;
assert(litlen >= 0);
if (litlen >= (int)RUN_MASK)
@ -1232,8 +1233,7 @@ LZ4_FORCE_INLINE int LZ4HC_literalsPrice(int const litlen)
/* requires mlen >= MINMATCH */
LZ4_FORCE_INLINE int LZ4HC_sequencePrice(int litlen, int mlen)
{
LZ4_FORCE_INLINE int LZ4HC_sequencePrice(int litlen, int mlen) {
int price = 1 + 2 ; /* token + 16-bit offset */
assert(litlen >= 0);
assert(mlen >= MINMATCH);
@ -1257,8 +1257,7 @@ LZ4HC_FindLongerMatch(LZ4HC_CCtx_internal* const ctx,
const BYTE *ip, const BYTE *const iHighLimit,
int minLen, int nbSearches,
const dictCtx_directive dict,
const HCfavor_e favorDecSpeed)
{
const HCfavor_e favorDecSpeed) {
LZ4HC_match_t match = { 0, 0 };
const BYTE *matchPtr = NULL;
/* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
@ -1285,8 +1284,7 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
const limitedOutput_directive limit,
int const fullUpdate,
const dictCtx_directive dict,
const HCfavor_e favorDecSpeed)
{
const HCfavor_e favorDecSpeed) {
int retval = 0;
#define TRAILING_LITERALS 3
#ifdef LZ4HC_HEAPMODE
@ -1334,7 +1332,8 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
}
/* set prices for first positions (literals) */
{ int rPos;
{
int rPos;
for (rPos = 0 ; rPos < MINMATCH ; rPos++) {
int const cost = LZ4HC_literalsPrice(llen + rPos);
opt[rPos].mlen = 1;
@ -1343,9 +1342,11 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
opt[rPos].price = cost;
DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
rPos, cost, opt[rPos].litlen);
} }
}
}
/* set prices using initial match */
{ int mlen = MINMATCH;
{
int mlen = MINMATCH;
int const matchML = firstMatch.len; /* necessarily < sufficient_len < LZ4_OPT_NUM */
int const offset = firstMatch.off;
assert(matchML < LZ4_OPT_NUM);
@ -1357,9 +1358,11 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
opt[mlen].price = cost;
DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i) -- initial setup",
mlen, cost, mlen);
} }
}
}
last_match_pos = firstMatch.len;
{ int addLit;
{
int addLit;
for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
opt[last_match_pos + addLit].mlen = 1; /* literal */
opt[last_match_pos + addLit].off = 0;
@ -1367,7 +1370,8 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
opt[last_match_pos + addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
last_match_pos + addLit, opt[last_match_pos + addLit].price, addLit);
} }
}
}
/* check further positions */
for (cur = 1; cur < last_match_pos; cur++) {
@ -1406,7 +1410,8 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
}
/* before match : set price with literals at beginning */
{ int const baseLitlen = opt[cur].litlen;
{
int const baseLitlen = opt[cur].litlen;
int litlen;
for (litlen = 1; litlen < MINMATCH; litlen++) {
int const price = opt[cur].price - LZ4HC_literalsPrice(baseLitlen) + LZ4HC_literalsPrice(baseLitlen + litlen);
@ -1418,10 +1423,13 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
opt[pos].price = price;
DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)",
pos, price, opt[pos].litlen);
} } }
}
}
}
/* set prices using match at position = cur */
{ int const matchML = newMatch.len;
{
int const matchML = newMatch.len;
int ml = MINMATCH;
assert(cur + newMatch.len < LZ4_OPT_NUM);
@ -1454,16 +1462,20 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
opt[pos].off = offset;
opt[pos].litlen = ll;
opt[pos].price = price;
} } }
}
}
}
/* complete following positions with literals */
{ int addLit;
{
int addLit;
for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
opt[last_match_pos + addLit].mlen = 1; /* literal */
opt[last_match_pos + addLit].off = 0;
opt[last_match_pos + addLit].litlen = addLit;
opt[last_match_pos + addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)", last_match_pos + addLit, opt[last_match_pos + addLit].price, addLit);
} }
}
}
} /* for (cur = 1; cur <= last_match_pos; cur++) */
assert(last_match_pos < LZ4_OPT_NUM + TRAILING_LITERALS);
@ -1475,7 +1487,8 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
assert(cur < LZ4_OPT_NUM);
assert(last_match_pos >= 1); /* == 1 when only one candidate */
DEBUGLOG(6, "reverse traversal, looking for shortest path (last_match_pos=%i)", last_match_pos);
{ int candidate_pos = cur;
{
int candidate_pos = cur;
int selected_matchLength = best_mlen;
int selected_offset = best_off;
while (1) { /* from end to beginning */
@ -1489,10 +1502,12 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
if (next_matchLength > candidate_pos) break; /* last match elected, first match to encode */
assert(next_matchLength > 0); /* can be 1, means literal */
candidate_pos -= next_matchLength;
} }
}
}
/* encode all recorded sequences in order */
{ int rPos = 0; /* relative position (to ip) */
{
int rPos = 0; /* relative position (to ip) */
while (rPos < last_match_pos) {
int const ml = opt[rPos].mlen;
int const offset = opt[rPos].off;
@ -1503,12 +1518,14 @@ static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
opSaved = op;
if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, ip - offset, limit, oend)) /* updates ip, op and anchor */
goto _dest_overflow;
} }
}
}
} /* while (ip <= mflimit) */
_last_literals:
/* Encode Last Literals */
{ size_t lastRunSize = (size_t)(iend - anchor); /* literals */
{
size_t lastRunSize = (size_t)(iend - anchor); /* literals */
size_t litLength = (lastRunSize + 255 - RUN_MASK) / 255;
size_t const totalSize = 1 + litLength + lastRunSize;
if (limit == fillOutput) oend += LASTLITERALS; /* restore correct value */

6
common/lz4/lz4hc.h
View file

@ -202,8 +202,7 @@ LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, in
#include <stdint.h>
typedef struct LZ4HC_CCtx_internal LZ4HC_CCtx_internal;
struct LZ4HC_CCtx_internal
{
struct LZ4HC_CCtx_internal {
uint32_t hashTable[LZ4HC_HASHTABLESIZE];
uint16_t chainTable[LZ4HC_MAXD];
const uint8_t *end; /* next block here to continue on current prefix */
@ -222,8 +221,7 @@ struct LZ4HC_CCtx_internal
#else
typedef struct LZ4HC_CCtx_internal LZ4HC_CCtx_internal;
struct LZ4HC_CCtx_internal
{
struct LZ4HC_CCtx_internal {
unsigned int hashTable[LZ4HC_HASHTABLESIZE];
unsigned short chainTable[LZ4HC_MAXD];
const unsigned char *end; /* next block here to continue on current prefix */