colin/u-boot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lib: Remove duplicate newlines

Browse Source 
Drop all duplicate newlines. No functional change.

Signed-off-by: Marek Vasut <marek.vasut+renesas@mailbox.org>
This commit is contained in:
Marek Vasut
2024-07-13 15:19:22 +02:00
committed by Tom Rini
parent dc5e205713
commit 2f8c004a5a
58 changed files with 0 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
lib/blake2/blake2b.c
View File

@@ -51,7 +51,6 @@ static const uint8_t blake2b_sigma[12][16] =
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
}; };
static void blake2b_set_lastnode( blake2b_state *S ) static void blake2b_set_lastnode( blake2b_state *S )
{ {
S->f[1] = (uint64_t)-1; S->f[1] = (uint64_t)-1;
@@ -100,8 +99,6 @@ int blake2b_init_param( blake2b_state *S, const blake2b_param *P )
return 0; return 0;
} }
int blake2b_init( blake2b_state *S, size_t outlen ) int blake2b_init( blake2b_state *S, size_t outlen )
{ {
blake2b_param P[1]; blake2b_param P[1];
@@ -123,7 +120,6 @@ int blake2b_init( blake2b_state *S, size_t outlen )
return blake2b_init_param( S, P ); return blake2b_init_param( S, P );
} }
int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen ) int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen )
{ {
blake2b_param P[1]; blake2b_param P[1];

41
lib/bzip2/bzlib.c
View File

@@ -87,7 +87,6 @@
/*--- Compression stuff ---*/ /*--- Compression stuff ---*/
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*---------------------------------------------------*/ /*---------------------------------------------------*/
#ifndef BZ_NO_STDIO #ifndef BZ_NO_STDIO
void BZ2_bz__AssertH__fail ( int errcode ) void BZ2_bz__AssertH__fail ( int errcode )
@@ -137,7 +136,6 @@ void BZ2_bz__AssertH__fail ( int errcode )
} }
#endif #endif
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
int bz_config_ok ( void ) int bz_config_ok ( void )
@@ -148,7 +146,6 @@ int bz_config_ok ( void )
return 1; return 1;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void* default_bzalloc ( void* opaque, Int32 items, Int32 size ) void* default_bzalloc ( void* opaque, Int32 items, Int32 size )
@@ -177,7 +174,6 @@ void prepare_new_block ( EState* s )
s->blockNo++; s->blockNo++;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void init_RL ( EState* s ) void init_RL ( EState* s )
@@ -186,7 +182,6 @@ void init_RL ( EState* s )
s->state_in_len = 0; s->state_in_len = 0;
} }
static static
Bool isempty_RL ( EState* s ) Bool isempty_RL ( EState* s )
{ {
@@ -261,7 +256,6 @@ int BZ_API(BZ2_bzCompressInit)
return BZ_OK; return BZ_OK;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void add_pair_to_block ( EState* s ) void add_pair_to_block ( EState* s )
@@ -297,7 +291,6 @@ void add_pair_to_block ( EState* s )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void flush_RL ( EState* s ) void flush_RL ( EState* s )
@@ -306,7 +299,6 @@ void flush_RL ( EState* s )
init_RL ( s ); init_RL ( s );
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
#define ADD_CHAR_TO_BLOCK(zs,zchh0) \ #define ADD_CHAR_TO_BLOCK(zs,zchh0) \
{ \ { \
@@ -334,7 +326,6 @@ void flush_RL ( EState* s )
} \ } \
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
Bool copy_input_until_stop ( EState* s ) Bool copy_input_until_stop ( EState* s )
@@ -379,7 +370,6 @@ Bool copy_input_until_stop ( EState* s )
return progress_in; return progress_in;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
Bool copy_output_until_stop ( EState* s ) Bool copy_output_until_stop ( EState* s )
@@ -406,7 +396,6 @@ Bool copy_output_until_stop ( EState* s )
return progress_out; return progress_out;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
Bool handle_compress ( bz_stream* strm ) Bool handle_compress ( bz_stream* strm )
@@ -453,7 +442,6 @@ Bool handle_compress ( bz_stream* strm )
return progress_in || progress_out; return progress_in || progress_out;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action ) int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
{ {
@@ -514,7 +502,6 @@ int BZ_API(BZ2_bzCompress) ( bz_stream *strm, int action )
return BZ_OK; /*--not reached--*/ return BZ_OK; /*--not reached--*/
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzCompressEnd) ( bz_stream *strm ) int BZ_API(BZ2_bzCompressEnd) ( bz_stream *strm )
{ {
@@ -578,7 +565,6 @@ int BZ_API(BZ2_bzDecompressInit)
return BZ_OK; return BZ_OK;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void unRLE_obuf_to_output_FAST ( DState* s ) void unRLE_obuf_to_output_FAST ( DState* s )
@@ -604,7 +590,6 @@ void unRLE_obuf_to_output_FAST ( DState* s )
/* can a new run be started? */ /* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return; if (s->nblock_used == s->save_nblock+1) return;
s->state_out_len = 1; s->state_out_len = 1;
s->state_out_ch = s->k0; s->state_out_ch = s->k0;
BZ_GET_FAST(k1); BZ_RAND_UPD_MASK; BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
@@ -720,7 +705,6 @@ void unRLE_obuf_to_output_FAST ( DState* s )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
__inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab ) __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
{ {
@@ -735,7 +719,6 @@ __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
return nb; return nb;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void unRLE_obuf_to_output_SMALL ( DState* s ) void unRLE_obuf_to_output_SMALL ( DState* s )
@@ -761,7 +744,6 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
/* can a new run be started? */ /* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return; if (s->nblock_used == s->save_nblock+1) return;
s->state_out_len = 1; s->state_out_len = 1;
s->state_out_ch = s->k0; s->state_out_ch = s->k0;
BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK; BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
@@ -831,7 +813,6 @@ void unRLE_obuf_to_output_SMALL ( DState* s )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzDecompress) ( bz_stream *strm ) int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
{ {
@@ -886,7 +867,6 @@ int BZ_API(BZ2_bzDecompress) ( bz_stream *strm )
return 0; /*NOTREACHED*/ return 0; /*NOTREACHED*/
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm ) int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm )
{ {
@@ -906,7 +886,6 @@ int BZ_API(BZ2_bzDecompressEnd) ( bz_stream *strm )
return BZ_OK; return BZ_OK;
} }
#ifndef BZ_NO_STDIO #ifndef BZ_NO_STDIO
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*--- File I/O stuff ---*/ /*--- File I/O stuff ---*/
@@ -930,7 +909,6 @@ typedef
} }
bzFile; bzFile;
/*---------------------------------------------*/ /*---------------------------------------------*/
static Bool myfeof ( FILE* f ) static Bool myfeof ( FILE* f )
{ {
@@ -940,7 +918,6 @@ static Bool myfeof ( FILE* f )
return False; return False;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
BZFILE* BZ_API(BZ2_bzWriteOpen) BZFILE* BZ_API(BZ2_bzWriteOpen)
( int* bzerror, ( int* bzerror,
@@ -987,7 +964,6 @@ BZFILE* BZ_API(BZ2_bzWriteOpen)
return bzf; return bzf;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ_API(BZ2_bzWrite) void BZ_API(BZ2_bzWrite)
( int* bzerror, ( int* bzerror,
@@ -1032,7 +1008,6 @@ void BZ_API(BZ2_bzWrite)
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ_API(BZ2_bzWriteClose) void BZ_API(BZ2_bzWriteClose)
( int* bzerror, ( int* bzerror,
@@ -1045,7 +1020,6 @@ void BZ_API(BZ2_bzWriteClose)
nbytes_in, NULL, nbytes_out, NULL ); nbytes_in, NULL, nbytes_out, NULL );
} }
void BZ_API(BZ2_bzWriteClose64) void BZ_API(BZ2_bzWriteClose64)
( int* bzerror, ( int* bzerror,
BZFILE* b, BZFILE* b,
@@ -1110,7 +1084,6 @@ void BZ_API(BZ2_bzWriteClose64)
free ( bzf ); free ( bzf );
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
BZFILE* BZ_API(BZ2_bzReadOpen) BZFILE* BZ_API(BZ2_bzReadOpen)
( int* bzerror, ( int* bzerror,
@@ -1166,7 +1139,6 @@ BZFILE* BZ_API(BZ2_bzReadOpen)
return bzf; return bzf;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b ) void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
{ {
@@ -1184,7 +1156,6 @@ void BZ_API(BZ2_bzReadClose) ( int *bzerror, BZFILE *b )
free ( bzf ); free ( bzf );
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzRead) int BZ_API(BZ2_bzRead)
( int* bzerror, ( int* bzerror,
@@ -1244,7 +1215,6 @@ int BZ_API(BZ2_bzRead)
return 0; /*not reached*/ return 0; /*not reached*/
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ_API(BZ2_bzReadGetUnused) void BZ_API(BZ2_bzReadGetUnused)
( int* bzerror, ( int* bzerror,
@@ -1266,7 +1236,6 @@ void BZ_API(BZ2_bzReadGetUnused)
} }
#endif #endif
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*--- Misc convenience stuff ---*/ /*--- Misc convenience stuff ---*/
/*---------------------------------------------------*/ /*---------------------------------------------------*/
@@ -1372,7 +1341,6 @@ int BZ_API(BZ2_bzBuffToBuffDecompress)
return ret; return ret;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*-- /*--
Code contributed by Yoshioka Tsuneo Code contributed by Yoshioka Tsuneo
@@ -1394,7 +1362,6 @@ const char * BZ_API(BZ2_bzlibVersion)(void)
return BZ_VERSION; return BZ_VERSION;
} }
#ifndef BZ_NO_STDIO #ifndef BZ_NO_STDIO
/*---------------------------------------------------*/ /*---------------------------------------------------*/
@@ -1476,7 +1443,6 @@ BZFILE * bzopen_or_bzdopen
return bzfp; return bzfp;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*-- /*--
open file for read or write. open file for read or write.
@@ -1490,7 +1456,6 @@ BZFILE * BZ_API(BZ2_bzopen)
return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0); return bzopen_or_bzdopen(path,-1,mode,/*bzopen*/0);
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
BZFILE * BZ_API(BZ2_bzdopen) BZFILE * BZ_API(BZ2_bzdopen)
( int fd, ( int fd,
@@ -1499,7 +1464,6 @@ BZFILE * BZ_API(BZ2_bzdopen)
return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1); return bzopen_or_bzdopen(NULL,fd,mode,/*bzdopen*/1);
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len ) int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
{ {
@@ -1513,7 +1477,6 @@ int BZ_API(BZ2_bzread) (BZFILE* b, void* buf, int len )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len ) int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len )
{ {
@@ -1527,7 +1490,6 @@ int BZ_API(BZ2_bzwrite) (BZFILE* b, void* buf, int len )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
int BZ_API(BZ2_bzflush) (BZFILE *b) int BZ_API(BZ2_bzflush) (BZFILE *b)
{ {
@@ -1535,7 +1497,6 @@ int BZ_API(BZ2_bzflush) (BZFILE *b)
return 0; return 0;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ_API(BZ2_bzclose) (BZFILE* b) void BZ_API(BZ2_bzclose) (BZFILE* b)
{ {
@@ -1556,7 +1517,6 @@ void BZ_API(BZ2_bzclose) (BZFILE* b)
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*-- /*--
return last error code return last error code
@@ -1580,7 +1540,6 @@ static char *bzerrorstrings[] = {
,"???" /* for future */ ,"???" /* for future */
}; };
const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum) const char * BZ_API(BZ2_bzerror) (BZFILE *b, int *errnum)
{ {
int err = ((bzFile *)b)->lastErr; int err = ((bzFile *)b)->lastErr;

12
lib/bzip2/bzlib_blocksort.c
View File

@@ -99,7 +99,6 @@ void fallbackSimpleSort ( UInt32* fmap,
} }
} }
/*---------------------------------------------*/ /*---------------------------------------------*/
#define fswap(zz1, zz2) \ #define fswap(zz1, zz2) \
{ Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; } { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; }
@@ -115,7 +114,6 @@ void fallbackSimpleSort ( UInt32* fmap,
} \ } \
} }
#define fmin(a,b) ((a) < (b)) ? (a) : (b) #define fmin(a,b) ((a) < (b)) ? (a) : (b)
#define fpush(lz,hz) { stackLo[sp] = lz; \ #define fpush(lz,hz) { stackLo[sp] = lz; \
@@ -129,7 +127,6 @@ void fallbackSimpleSort ( UInt32* fmap,
#define FALLBACK_QSORT_SMALL_THRESH 10 #define FALLBACK_QSORT_SMALL_THRESH 10
#define FALLBACK_QSORT_STACK_SIZE 100 #define FALLBACK_QSORT_STACK_SIZE 100
static static
void fallbackQSort3 ( UInt32* fmap, void fallbackQSort3 ( UInt32* fmap,
UInt32* eclass, UInt32* eclass,
@@ -228,7 +225,6 @@ void fallbackQSort3 ( UInt32* fmap,
#undef FALLBACK_QSORT_SMALL_THRESH #undef FALLBACK_QSORT_SMALL_THRESH
#undef FALLBACK_QSORT_STACK_SIZE #undef FALLBACK_QSORT_STACK_SIZE
/*---------------------------------------------*/ /*---------------------------------------------*/
/* Pre: /* Pre:
nblock > 0 nblock > 0
@@ -375,7 +371,6 @@ void fallbackSort ( UInt32* fmap,
#undef WORD_BH #undef WORD_BH
#undef UNALIGNED_BH #undef UNALIGNED_BH
/*---------------------------------------------*/ /*---------------------------------------------*/
/*--- The main, O(N^2 log(N)) sorting ---*/ /*--- The main, O(N^2 log(N)) sorting ---*/
/*--- algorithm. Faster for "normal" ---*/ /*--- algorithm. Faster for "normal" ---*/
@@ -509,7 +504,6 @@ Bool mainGtU ( UInt32 i1,
return False; return False;
} }
/*---------------------------------------------*/ /*---------------------------------------------*/
/*-- /*--
Knuth's increments seem to work better Knuth's increments seem to work better
@@ -595,7 +589,6 @@ void mainSimpleSort ( UInt32* ptr,
} }
} }
/*---------------------------------------------*/ /*---------------------------------------------*/
/*-- /*--
The following is an implementation of The following is an implementation of
@@ -644,7 +637,6 @@ UChar mmed3 ( UChar a, UChar b, UChar c )
hz = stackHi[sp]; \ hz = stackHi[sp]; \
dz = stackD [sp]; } dz = stackD [sp]; }
#define mnextsize(az) (nextHi[az]-nextLo[az]) #define mnextsize(az) (nextHi[az]-nextLo[az])
#define mnextswap(az,bz) \ #define mnextswap(az,bz) \
@@ -653,7 +645,6 @@ UChar mmed3 ( UChar a, UChar b, UChar c )
tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \ tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \
tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; } tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; }
#define MAIN_QSORT_SMALL_THRESH 20 #define MAIN_QSORT_SMALL_THRESH 20
#define MAIN_QSORT_DEPTH_THRESH (BZ_N_RADIX + BZ_N_QSORT) #define MAIN_QSORT_DEPTH_THRESH (BZ_N_RADIX + BZ_N_QSORT)
#define MAIN_QSORT_STACK_SIZE 100 #define MAIN_QSORT_STACK_SIZE 100
@@ -768,7 +759,6 @@ void mainQSort3 ( UInt32* ptr,
#undef MAIN_QSORT_DEPTH_THRESH #undef MAIN_QSORT_DEPTH_THRESH
#undef MAIN_QSORT_STACK_SIZE #undef MAIN_QSORT_STACK_SIZE
/*---------------------------------------------*/ /*---------------------------------------------*/
/* Pre: /* Pre:
nblock > N_OVERSHOOT nblock > N_OVERSHOOT
@@ -1055,7 +1045,6 @@ void mainSort ( UInt32* ptr,
#undef SETMASK #undef SETMASK
#undef CLEARMASK #undef CLEARMASK
/*---------------------------------------------*/ /*---------------------------------------------*/
/* Pre: /* Pre:
nblock > 0 nblock > 0
@@ -1129,7 +1118,6 @@ void BZ2_blockSort ( EState* s )
AssertH( s->origPtr != -1, 1003 ); AssertH( s->origPtr != -1, 1003 );
} }
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- end blocksort.c ---*/ /*--- end blocksort.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/

15
lib/bzip2/bzlib_compress.c
View File

@@ -80,7 +80,6 @@ void BZ2_bsInitWrite ( EState* s )
s->bsBuff = 0; s->bsBuff = 0;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void bsFinishWrite ( EState* s ) void bsFinishWrite ( EState* s )
@@ -93,7 +92,6 @@ void bsFinishWrite ( EState* s )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
#define bsNEEDW(nz) \ #define bsNEEDW(nz) \
{ \ { \
@@ -106,7 +104,6 @@ void bsFinishWrite ( EState* s )
} \ } \
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
__inline__ __inline__
@@ -117,7 +114,6 @@ void bsW ( EState* s, Int32 n, UInt32 v )
s->bsLive += n; s->bsLive += n;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void bsPutUInt32 ( EState* s, UInt32 u ) void bsPutUInt32 ( EState* s, UInt32 u )
@@ -128,7 +124,6 @@ void bsPutUInt32 ( EState* s, UInt32 u )
bsW ( s, 8, u & 0xffL ); bsW ( s, 8, u & 0xffL );
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void bsPutUChar ( EState* s, UChar c ) void bsPutUChar ( EState* s, UChar c )
@@ -136,7 +131,6 @@ void bsPutUChar ( EState* s, UChar c )
bsW( s, 8, (UInt32)c ); bsW( s, 8, (UInt32)c );
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
/*--- The back end proper ---*/ /*--- The back end proper ---*/
/*---------------------------------------------------*/ /*---------------------------------------------------*/
@@ -154,7 +148,6 @@ void makeMaps_e ( EState* s )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void generateMTFValues ( EState* s ) void generateMTFValues ( EState* s )
@@ -270,7 +263,6 @@ void generateMTFValues ( EState* s )
s->nMTF = wr; s->nMTF = wr;
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
#define BZ_LESSER_ICOST 0 #define BZ_LESSER_ICOST 0
#define BZ_GREATER_ICOST 15 #define BZ_GREATER_ICOST 15
@@ -293,7 +285,6 @@ void sendMTFValues ( EState* s )
Made global to keep stack frame size small. Made global to keep stack frame size small.
--*/ --*/
UInt16 cost[BZ_N_GROUPS]; UInt16 cost[BZ_N_GROUPS];
Int32 fave[BZ_N_GROUPS]; Int32 fave[BZ_N_GROUPS];
@@ -492,13 +483,11 @@ void sendMTFValues ( EState* s )
alphaSize, 17 /*20*/ ); alphaSize, 17 /*20*/ );
} }
AssertH( nGroups < 8, 3002 ); AssertH( nGroups < 8, 3002 );
AssertH( nSelectors < 32768 && AssertH( nSelectors < 32768 &&
nSelectors <= (2 + (900000 / BZ_G_SIZE)), nSelectors <= (2 + (900000 / BZ_G_SIZE)),
3003 ); 3003 );
/*--- Compute MTF values for the selectors. ---*/ /*--- Compute MTF values for the selectors. ---*/
{ {
UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp; UChar pos[BZ_N_GROUPS], ll_i, tmp2, tmp;
@@ -628,7 +617,6 @@ void sendMTFValues ( EState* s )
} }
} }
gs = ge+1; gs = ge+1;
selCtr++; selCtr++;
} }
@@ -638,7 +626,6 @@ void sendMTFValues ( EState* s )
VPrintf1( "codes %d\n", s->numZ-nBytes ); VPrintf1( "codes %d\n", s->numZ-nBytes );
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ2_compressBlock ( EState* s, Bool is_last_block ) void BZ2_compressBlock ( EState* s, Bool is_last_block )
{ {
@@ -693,7 +680,6 @@ void BZ2_compressBlock ( EState* s, Bool is_last_block )
sendMTFValues ( s ); sendMTFValues ( s );
} }
/*-- If this is the last block, add the stream trailer. --*/ /*-- If this is the last block, add the stream trailer. --*/
if (is_last_block) { if (is_last_block) {
@@ -707,7 +693,6 @@ void BZ2_compressBlock ( EState* s, Bool is_last_block )
} }
} }
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- end compress.c ---*/ /*--- end compress.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/

2
lib/bzip2/bzlib_crctable.c
View File

@@ -59,7 +59,6 @@
For more information on these sources, see the manual. For more information on these sources, see the manual.
--*/ --*/
#include "bzlib_private.h" #include "bzlib_private.h"
/*-- /*--
@@ -139,7 +138,6 @@ UInt32 BZ2_crc32Table[256] = {
0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L 0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
}; };
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- end crctable.c ---*/ /*--- end crctable.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/

6
lib/bzip2/bzlib_decompress.c
View File

@@ -60,10 +60,8 @@
For more information on these sources, see the manual. For more information on these sources, see the manual.
--*/ --*/
#include "bzlib_private.h" #include "bzlib_private.h"
/*---------------------------------------------------*/ /*---------------------------------------------------*/
static static
void makeMaps_d ( DState* s ) void makeMaps_d ( DState* s )
@@ -77,7 +75,6 @@ void makeMaps_d ( DState* s )
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
#define RETURN(rrr) \ #define RETURN(rrr) \
{ retVal = rrr; goto save_state_and_return; }; { retVal = rrr; goto save_state_and_return; };
@@ -143,7 +140,6 @@ void makeMaps_d ( DState* s )
lval = gPerm[zvec - gBase[zn]]; \ lval = gPerm[zvec - gBase[zn]]; \
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
Int32 BZ2_decompress ( DState* s ) Int32 BZ2_decompress ( DState* s )
{ {
@@ -605,7 +601,6 @@ Int32 BZ2_decompress ( DState* s )
RETURN(BZ_OK); RETURN(BZ_OK);
endhdr_2: endhdr_2:
GET_UCHAR(BZ_X_ENDHDR_2, uc); GET_UCHAR(BZ_X_ENDHDR_2, uc);
@@ -667,7 +662,6 @@ Int32 BZ2_decompress ( DState* s )
return retVal; return retVal;
} }
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- end decompress.c ---*/ /*--- end decompress.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/

5
lib/bzip2/bzlib_huffman.c
View File

@@ -59,7 +59,6 @@
For more information on these sources, see the manual. For more information on these sources, see the manual.
--*/ --*/
#include "bzlib_private.h" #include "bzlib_private.h"
/*---------------------------------------------------*/ /*---------------------------------------------------*/
@@ -99,7 +98,6 @@
heap[zz] = tmp; \ heap[zz] = tmp; \
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ2_hbMakeCodeLengths ( UChar *len, void BZ2_hbMakeCodeLengths ( UChar *len,
Int32 *freq, Int32 *freq,
@@ -171,7 +169,6 @@ void BZ2_hbMakeCodeLengths ( UChar *len,
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ2_hbAssignCodes ( Int32 *code, void BZ2_hbAssignCodes ( Int32 *code,
UChar *length, UChar *length,
@@ -189,7 +186,6 @@ void BZ2_hbAssignCodes ( Int32 *code,
} }
} }
/*---------------------------------------------------*/ /*---------------------------------------------------*/
void BZ2_hbCreateDecodeTables ( Int32 *limit, void BZ2_hbCreateDecodeTables ( Int32 *limit,
Int32 *base, Int32 *base,
@@ -223,7 +219,6 @@ void BZ2_hbCreateDecodeTables ( Int32 *limit,
base[i] = ((limit[i-1] + 1) << 1) - base[i]; base[i] = ((limit[i-1] + 1) << 1) - base[i];
} }
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- end huffman.c ---*/ /*--- end huffman.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/

17
lib/bzip2/bzlib_private.h
View File

@@ -62,7 +62,6 @@
For more information on these sources, see the manual. For more information on these sources, see the manual.
--*/ --*/
#ifndef _BZLIB_PRIVATE_H #ifndef _BZLIB_PRIVATE_H
#define _BZLIB_PRIVATE_H #define _BZLIB_PRIVATE_H
@@ -76,7 +75,6 @@
#include <string.h> #include <string.h>
#endif #endif
/*-- General stuff. --*/ /*-- General stuff. --*/
#define BZ_VERSION "1.0.2, 30-Dec-2001" #define BZ_VERSION "1.0.2, 30-Dec-2001"
@@ -135,11 +133,9 @@ extern void bz_internal_error ( int errcode );
#define VPrintf5(zf,za1,za2,za3,za4,za5) /* */ #define VPrintf5(zf,za1,za2,za3,za4,za5) /* */
#endif #endif
#define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1) #define BZALLOC(nnn) (strm->bzalloc)(strm->opaque,(nnn),1)
#define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp)) #define BZFREE(ppp) (strm->bzfree)(strm->opaque,(ppp))
/*-- Header bytes. --*/ /*-- Header bytes. --*/
#define BZ_HDR_B 0x42 /* 'B' */ #define BZ_HDR_B 0x42 /* 'B' */
@@ -161,7 +157,6 @@ extern void bz_internal_error ( int errcode );
#define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE)) #define BZ_MAX_SELECTORS (2 + (900000 / BZ_G_SIZE))
/*-- Stuff for randomising repetitive blocks. --*/ /*-- Stuff for randomising repetitive blocks. --*/
extern Int32 BZ2_rNums[512]; extern Int32 BZ2_rNums[512];
@@ -184,7 +179,6 @@ extern Int32 BZ2_rNums[512];
} \ } \
s->rNToGo--; s->rNToGo--;
/*-- Stuff for doing CRCs. --*/ /*-- Stuff for doing CRCs. --*/
extern UInt32 BZ2_crc32Table[256]; extern UInt32 BZ2_crc32Table[256];
@@ -206,7 +200,6 @@ extern UInt32 BZ2_crc32Table[256];
((UChar)cha)]; \ ((UChar)cha)]; \
} }
/*-- States and modes for compression. --*/ /*-- States and modes for compression. --*/
#define BZ_M_IDLE 1 #define BZ_M_IDLE 1
@@ -222,7 +215,6 @@ extern UInt32 BZ2_crc32Table[256];
#define BZ_N_SHELL 18 #define BZ_N_SHELL 18
#define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2) #define BZ_N_OVERSHOOT (BZ_N_RADIX + BZ_N_QSORT + BZ_N_SHELL + 2)
/*-- Structure holding all the compression-side stuff. --*/ /*-- Structure holding all the compression-side stuff. --*/
typedef typedef
@@ -297,7 +289,6 @@ typedef
} }
EState; EState;
/*-- externs for compression. --*/ /*-- externs for compression. --*/
extern void extern void
@@ -315,7 +306,6 @@ BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
extern void extern void
BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 ); BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
/*-- states for decompression. --*/ /*-- states for decompression. --*/
#define BZ_X_IDLE 1 #define BZ_X_IDLE 1
@@ -363,13 +353,11 @@ BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
#define BZ_X_CCRC_3 49 #define BZ_X_CCRC_3 49
#define BZ_X_CCRC_4 50 #define BZ_X_CCRC_4 50
/*-- Constants for the fast MTF decoder. --*/ /*-- Constants for the fast MTF decoder. --*/
#define MTFA_SIZE 4096 #define MTFA_SIZE 4096
#define MTFL_SIZE 16 #define MTFL_SIZE 16
/*-- Structure holding all the decompression-side stuff. --*/ /*-- Structure holding all the decompression-side stuff. --*/
typedef typedef
@@ -465,7 +453,6 @@ typedef
} }
DState; DState;
/*-- Macros for decompression. --*/ /*-- Macros for decompression. --*/
#define BZ_GET_FAST(cccc) \ #define BZ_GET_FAST(cccc) \
@@ -499,7 +486,6 @@ typedef
cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \ cccc = BZ2_indexIntoF ( s->tPos, s->cftab ); \
s->tPos = GET_LL(s->tPos); s->tPos = GET_LL(s->tPos);
/*-- externs for decompression. --*/ /*-- externs for decompression. --*/
extern Int32 extern Int32
@@ -512,10 +498,8 @@ extern void
BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*, BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
Int32, Int32, Int32 ); Int32, Int32, Int32 );
#endif #endif
/*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/ /*-- BZ_NO_STDIO seems to make NULL disappear on some platforms. --*/
#ifdef BZ_NO_STDIO #ifdef BZ_NO_STDIO
@@ -524,7 +508,6 @@ BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
#endif #endif
#endif #endif
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- end bzlib_private.h ---*/ /*--- end bzlib_private.h ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/

3
lib/bzip2/bzlib_randtable.c
View File

@@ -59,10 +59,8 @@
For more information on these sources, see the manual. For more information on these sources, see the manual.
--*/ --*/
#include "bzlib_private.h" #include "bzlib_private.h"
/*---------------------------------------------*/ /*---------------------------------------------*/
Int32 BZ2_rNums[512] = { Int32 BZ2_rNums[512] = {
619, 720, 127, 481, 931, 816, 813, 233, 566, 247, 619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
@@ -119,7 +117,6 @@ Int32 BZ2_rNums[512] = {
936, 638 936, 638
}; };
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/
/*--- end randtable.c ---*/ /*--- end randtable.c ---*/
/*-------------------------------------------------------------*/ /*-------------------------------------------------------------*/

1
lib/circbuf.c
View File

@@ -9,7 +9,6 @@
#include <circbuf.h> #include <circbuf.h>
int buf_init (circbuf_t * buf, unsigned int size) int buf_init (circbuf_t * buf, unsigned int size)
{ {
assert (buf != NULL); assert (buf != NULL);

1
lib/crc7.c
View File

@@ -8,7 +8,6 @@
#include <linux/types.h> #include <linux/types.h>
#include <linux/crc7.h> #include <linux/crc7.h>
/* Table for CRC-7 (polynomial x^7 + x^3 + 1) */ /* Table for CRC-7 (polynomial x^7 + x^3 + 1) */
const u8 crc7_syndrome_table[256] = { const u8 crc7_syndrome_table[256] = {
0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f,

1
lib/crypt/crypt-sha256.c
View File

@@ -72,7 +72,6 @@ struct sha256_buffer
static_assert (sizeof (struct sha256_buffer) <= ALG_SPECIFIC_SIZE, static_assert (sizeof (struct sha256_buffer) <= ALG_SPECIFIC_SIZE,
"ALG_SPECIFIC_SIZE is too small for SHA256"); "ALG_SPECIFIC_SIZE is too small for SHA256");
/* Use this instead of including errno.h */ /* Use this instead of including errno.h */
static int errno; static int errno;

1
lib/crypt/crypt-sha512.c
View File

@@ -72,7 +72,6 @@ struct sha512_buffer
static_assert (sizeof (struct sha512_buffer) <= ALG_SPECIFIC_SIZE, static_assert (sizeof (struct sha512_buffer) <= ALG_SPECIFIC_SIZE,
"ALG_SPECIFIC_SIZE is too small for SHA512"); "ALG_SPECIFIC_SIZE is too small for SHA512");
/* Use this instead of including errno.h */ /* Use this instead of including errno.h */
static int errno; static int errno;

2
lib/dhry/dhry.h
View File

@@ -365,7 +365,6 @@
*************************************************************************** ***************************************************************************
*/ */
/* Compiler and system dependent definitions: */ /* Compiler and system dependent definitions: */
#ifndef TIME #ifndef TIME
@@ -432,7 +431,6 @@ typedef struct record
} variant; } variant;
} Rec_Type, *Rec_Pointer; } Rec_Type, *Rec_Pointer;
/* /*
* dhry() - run dhrystone for a given number of iterations * dhry() - run dhrystone for a given number of iterations
* *

6
lib/dhry/dhry_1.c
View File

@@ -102,7 +102,6 @@ void Proc_3 (Rec_Pointer *Ptr_Ref_Par);
void Proc_4 (void); void Proc_4 (void);
void Proc_5 (void); void Proc_5 (void);
extern Boolean Func_2(Str_30, Str_30); extern Boolean Func_2(Str_30, Str_30);
extern void Proc_6(Enumeration, Enumeration *); extern void Proc_6(Enumeration, Enumeration *);
extern void Proc_7(One_Fifty, One_Fifty, One_Fifty *); extern void Proc_7(One_Fifty, One_Fifty, One_Fifty *);
@@ -323,7 +322,6 @@ void dhry(int Number_Of_Runs)
#endif /* SELF_TIMED */ #endif /* SELF_TIMED */
} }
void Proc_1 (REG Rec_Pointer Ptr_Val_Par) void Proc_1 (REG Rec_Pointer Ptr_Val_Par)
/* executed once */ /* executed once */
{ {
@@ -354,7 +352,6 @@ void Proc_1 (REG Rec_Pointer Ptr_Val_Par)
structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp); structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
} /* Proc_1 */ } /* Proc_1 */
void Proc_2 (One_Fifty *Int_Par_Ref) void Proc_2 (One_Fifty *Int_Par_Ref)
/* executed once */ /* executed once */
/* *Int_Par_Ref == 1, becomes 4 */ /* *Int_Par_Ref == 1, becomes 4 */
@@ -376,7 +373,6 @@ void Proc_2 (One_Fifty *Int_Par_Ref)
while (Enum_Loc != Ident_1); /* true */ while (Enum_Loc != Ident_1); /* true */
} /* Proc_2 */ } /* Proc_2 */
void Proc_3 (Rec_Pointer *Ptr_Ref_Par) void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
/* executed once */ /* executed once */
/* Ptr_Ref_Par becomes Ptr_Glob */ /* Ptr_Ref_Par becomes Ptr_Glob */
@@ -387,7 +383,6 @@ void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp); Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
} /* Proc_3 */ } /* Proc_3 */
void Proc_4 (void) /* without parameters */ void Proc_4 (void) /* without parameters */
/* executed once */ /* executed once */
{ {
@@ -406,7 +401,6 @@ void Proc_5 (void) /* without parameters */
Bool_Glob = false; Bool_Glob = false;
} /* Proc_5 */ } /* Proc_5 */
/* Procedure for the assignment of structures, */ /* Procedure for the assignment of structures, */
/* if the C compiler doesn't support this feature */ /* if the C compiler doesn't support this feature */
#ifdef NOSTRUCTASSIGN #ifdef NOSTRUCTASSIGN

5
lib/dhry/dhry_2.c
View File

@@ -106,7 +106,6 @@ One_Fifty *Int_Par_Ref;
*Int_Par_Ref = Int_2_Par_Val + Int_Loc; *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
} /* Proc_7 */ } /* Proc_7 */
void Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val) void Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
/*********************************************************************/ /*********************************************************************/
/* executed once */ /* executed once */
@@ -131,7 +130,6 @@ int Int_2_Par_Val;
Int_Glob = 5; Int_Glob = 5;
} /* Proc_8 */ } /* Proc_8 */
Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val) Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val)
/*************************************************/ /*************************************************/
/* executed three times */ /* executed three times */
@@ -154,8 +152,6 @@ Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val)
} }
} /* Func_1 */ } /* Func_1 */
Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref) Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
/*************************************************/ /*************************************************/
/* executed once */ /* executed once */
@@ -198,7 +194,6 @@ Str_30 Str_2_Par_Ref;
} /* if Ch_Loc */ } /* if Ch_Loc */
} /* Func_2 */ } /* Func_2 */
Boolean Func_3 (Enum_Par_Val) Boolean Func_3 (Enum_Par_Val)
/***************************/ /***************************/
/* executed once */ /* executed once */

1
lib/efi_loader/efi_capsule.c
View File

@@ -572,7 +572,6 @@ static efi_status_t efi_capsule_update_firmware(
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
/* Obtain the update_index from the platform */ /* Obtain the update_index from the platform */
status = fwu_plat_get_update_index(&update_index); status = fwu_plat_get_update_index(&update_index);
if (status < 0) { if (status < 0) {

1
lib/efi_loader/efi_console.c
View File

@@ -1176,7 +1176,6 @@ out:
return EFI_EXIT(ret); return EFI_EXIT(ret);
} }
/** /**
* efi_cin_reset() - drain the input buffer * efi_cin_reset() - drain the input buffer
* *

2
lib/efi_loader/efi_image_loader.c
View File

@@ -738,7 +738,6 @@ static bool efi_image_authenticate(void *efi, size_t efi_size)
log_debug("Message digest doesn't match\n"); log_debug("Message digest doesn't match\n");
} }
/* last resort try the image sha256 hash in db */ /* last resort try the image sha256 hash in db */
if (!ret && efi_signature_lookup_digest(regs, db, false)) if (!ret && efi_signature_lookup_digest(regs, db, false))
ret = true; ret = true;
@@ -761,7 +760,6 @@ static bool efi_image_authenticate(void *efi, size_t efi_size)
} }
#endif /* CONFIG_EFI_SECURE_BOOT */ #endif /* CONFIG_EFI_SECURE_BOOT */
/** /**
* efi_check_pe() - check if a memory buffer contains a PE-COFF image * efi_check_pe() - check if a memory buffer contains a PE-COFF image
* *

1
lib/efi_loader/efi_variable.c
View File

@@ -604,6 +604,5 @@ efi_status_t efi_init_variables(void)
log_err("Invalid EFI variable seed\n"); log_err("Invalid EFI variable seed\n");
} }
return efi_init_secure_state(); return efi_init_secure_state();
} }

1
lib/efi_selftest/efi_selftest_controllers.c
View File

@@ -447,7 +447,6 @@ static int execute(void)
return EFI_ST_FAILURE; return EFI_ST_FAILURE;
} }
return EFI_ST_SUCCESS; return EFI_ST_SUCCESS;
} }

1
lib/efi_selftest/efi_selftest_ecpt.c
View File

@@ -68,7 +68,6 @@ static int execute(void)
return EFI_ST_SUCCESS; return EFI_ST_SUCCESS;
} }
EFI_UNIT_TEST(ecpt) = { EFI_UNIT_TEST(ecpt) = {
.name = "conformance profile table", .name = "conformance profile table",
.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT, .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,

1
lib/efi_selftest/efi_selftest_load_file.c
View File

@@ -233,7 +233,6 @@ static efi_status_t EFIAPI load_file(struct efi_load_file_protocol *this,
return EFI_SUCCESS; return EFI_SUCCESS;
} }
/* /*
* load_file2() - LoadFile() service of a EFI_LOAD_FILE2_PROTOCOL * load_file2() - LoadFile() service of a EFI_LOAD_FILE2_PROTOCOL
* *

1
lib/fdtdec.c
View File

@@ -1182,7 +1182,6 @@ static int uncompress_blob(const void *src, ulong sz_src, void **dstp)
if (!gzip && !lzo) if (!gzip && !lzo)
return -EBADMSG; return -EBADMSG;
if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC)) { if (CONFIG_IS_ENABLED(MULTI_DTB_FIT_DYN_ALLOC)) {
dst = malloc(sz_out); dst = malloc(sz_out);
if (!dst) { if (!dst) {

1
lib/fwu_updates/fwu.c
View File

@@ -278,7 +278,6 @@ int fwu_get_mdata(struct fwu_mdata *mdata)
if (!err) if (!err)
goto ret_mdata; goto ret_mdata;
/* else read, verify and, if needed, fix mdata */ /* else read, verify and, if needed, fix mdata */
for (int i = 0; i < 2; i++) { for (int i = 0; i < 2; i++) {
parts_ok[i] = false; parts_ok[i] = false;

4
lib/hashtable.c
View File

@@ -58,7 +58,6 @@ struct env_entry_node {
struct env_entry entry; struct env_entry entry;
}; };
static void _hdelete(const char *key, struct hsearch_data *htab, static void _hdelete(const char *key, struct hsearch_data *htab,
struct env_entry *ep, int idx); struct env_entry *ep, int idx);
@@ -127,7 +126,6 @@ int hcreate_r(size_t nel, struct hsearch_data *htab)
return 1; return 1;
} }
/* /*
* hdestroy() * hdestroy()
*/ */
@@ -428,7 +426,6 @@ int hsearch_r(struct env_entry item, enum env_action action,
return 0; return 0;
} }
/* /*
* hdelete() * hdelete()
*/ */
@@ -718,7 +715,6 @@ ssize_t hexport_r(struct hsearch_data *htab, const char sep, int flag,
} }
#endif #endif
/* /*
* himport() * himport()
*/ */

1
lib/libavb/avb_sha.h
View File

@@ -24,7 +24,6 @@ extern "C" {
/* Block size in bytes of a SHA-256 digest. */ /* Block size in bytes of a SHA-256 digest. */
#define AVB_SHA256_BLOCK_SIZE 64 #define AVB_SHA256_BLOCK_SIZE 64
/* Block size in bytes of a SHA-512 digest. */ /* Block size in bytes of a SHA-512 digest. */
#define AVB_SHA512_BLOCK_SIZE 128 #define AVB_SHA512_BLOCK_SIZE 128

1
lib/lz4.c
View File

@@ -71,7 +71,6 @@ static void LZ4_wildCopy(void* dstPtr, const void* srcPtr, void* dstEnd)
do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e); do { LZ4_copy8(d,s); d+=8; s+=8; } while (d<e);
} }
/************************************** /**************************************
* Common Constants * Common Constants
**************************************/ **************************************/

3
lib/lzma/LzmaDec.c
View File

@@ -58,7 +58,6 @@
#define TREE_DECODE_CHECK(probs, limit, i) \ #define TREE_DECODE_CHECK(probs, limit, i) \
{ i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; } { i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }
#define kNumPosBitsMax 4 #define kNumPosBitsMax 4
#define kNumPosStatesMax (1 << kNumPosBitsMax) #define kNumPosStatesMax (1 << kNumPosBitsMax)
@@ -76,7 +75,6 @@
#define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits)) #define LenHigh (LenMid + (kNumPosStatesMax << kLenNumMidBits))
#define kNumLenProbs (LenHigh + kLenNumHighSymbols) #define kNumLenProbs (LenHigh + kLenNumHighSymbols)
#define kNumStates 12 #define kNumStates 12
#define kNumLitStates 7 #define kNumLitStates 7
@@ -689,7 +687,6 @@ static ELzmaDummy LzmaDec_TryDummy(const CLzmaDec *p, const Byte *buf, SizeT inS
return res; return res;
} }
static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data) static void LzmaDec_InitRc(CLzmaDec *p, const Byte *data)
{ {
p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]); p->code = ((UInt32)data[1] << 24) | ((UInt32)data[2] << 16) | ((UInt32)data[3] << 8) | ((UInt32)data[4]);

6
lib/lzma/LzmaDec.h
View File

@@ -16,7 +16,6 @@
#define CLzmaProb UInt16 #define CLzmaProb UInt16
#endif #endif
/* ---------- LZMA Properties ---------- */ /* ---------- LZMA Properties ---------- */
#define LZMA_PROPS_SIZE 5 #define LZMA_PROPS_SIZE 5
@@ -35,7 +34,6 @@ Returns:
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size); SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);
/* ---------- LZMA Decoder state ---------- */ /* ---------- LZMA Decoder state ---------- */
/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case. /* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
@@ -104,7 +102,6 @@ typedef enum
/* ELzmaStatus is used only as output value for function call */ /* ELzmaStatus is used only as output value for function call */
/* ---------- Interfaces ---------- */ /* ---------- Interfaces ---------- */
/* There are 3 levels of interfaces: /* There are 3 levels of interfaces:
@@ -114,7 +111,6 @@ typedef enum
You can select any of these interfaces, but don't mix functions from different You can select any of these interfaces, but don't mix functions from different
groups for same object. */ groups for same object. */
/* There are two variants to allocate state for Dictionary Interface: /* There are two variants to allocate state for Dictionary Interface:
1) LzmaDec_Allocate / LzmaDec_Free 1) LzmaDec_Allocate / LzmaDec_Free
2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs 2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
@@ -177,7 +173,6 @@ Returns:
SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit, SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
/* ---------- Buffer Interface ---------- */ /* ---------- Buffer Interface ---------- */
/* It's zlib-like interface. /* It's zlib-like interface.
@@ -194,7 +189,6 @@ finishMode:
SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen, SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status); const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);
/* ---------- One Call Interface ---------- */ /* ---------- One Call Interface ---------- */
/* LzmaDecode /* LzmaDecode

2
lib/lzma/Types.h
View File

@@ -84,7 +84,6 @@ typedef int Bool;
#define True 1 #define True 1
#define False 0 #define False 0
#ifdef _MSC_VER #ifdef _MSC_VER
#if _MSC_VER >= 1300 #if _MSC_VER >= 1300
@@ -103,7 +102,6 @@ typedef int Bool;
#endif #endif
/* The following interfaces use first parameter as pointer to structure */ /* The following interfaces use first parameter as pointer to structure */
typedef struct typedef struct

1
lib/lzo/lzo1x_decompress.c
View File

@@ -31,7 +31,6 @@ static const unsigned char lzop_magic[] = {
#define HEADER_HAS_FILTER 0x00000800L #define HEADER_HAS_FILTER 0x00000800L
bool lzop_is_valid_header(const unsigned char *src) bool lzop_is_valid_header(const unsigned char *src)
{ {
int i; int i;

1
lib/md5.c
View File

@@ -276,7 +276,6 @@ md5 (unsigned char *input, int len, unsigned char output[16])
MD5Final(output, &context); MD5Final(output, &context);
} }
/* /*
* Calculate and store in 'output' the MD5 digest of 'len' bytes at 'input'. * Calculate and store in 'output' the MD5 digest of 'len' bytes at 'input'.
* 'output' must have enough space to hold 16 bytes. If 'chunk' Trigger the * 'output' must have enough space to hold 16 bytes. If 'chunk' Trigger the

1
lib/string.c
View File

@@ -22,7 +22,6 @@
#include <linux/ctype.h> #include <linux/ctype.h>
#include <malloc.h> #include <malloc.h>
/** /**
* strncasecmp - Case insensitive, length-limited string comparison * strncasecmp - Case insensitive, length-limited string comparison
* @s1: One string * @s1: One string

2
lib/zlib/deflate.c
View File

@@ -164,7 +164,6 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */
*/ */
#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) #define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
/* =========================================================================== /* ===========================================================================
* Insert string str in the dictionary and set match_head to the previous head * Insert string str in the dictionary and set match_head to the previous head
* of the hash chain (the most recent string with same hash key). Return * of the hash chain (the most recent string with same hash key). Return
@@ -966,7 +965,6 @@ int ZEXPORT deflateCopy (dest, source)
deflate_state *ds; deflate_state *ds;
deflate_state *ss; deflate_state *ss;
if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) {
return Z_STREAM_ERROR; return Z_STREAM_ERROR;
} }

2
lib/zlib/deflate.h
View File

@@ -57,7 +57,6 @@
#define FINISH_STATE 666 #define FINISH_STATE 666
/* Stream status */ /* Stream status */
/* Data structure describing a single value and its code string. */ /* Data structure describing a single value and its code string. */
typedef struct ct_data_s { typedef struct ct_data_s {
union { union {
@@ -269,7 +268,6 @@ typedef struct internal_state {
*/ */
#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} #define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
/* Minimum amount of lookahead, except at the end of the input file. /* Minimum amount of lookahead, except at the end of the input file.
* See deflate.c for comments about the MIN_MATCH+1. * See deflate.c for comments about the MIN_MATCH+1.

2
lib/zlib/trees.c
View File

@@ -231,7 +231,6 @@ local void send_bits(s, value, length)
} }
#endif /* DEBUG */ #endif /* DEBUG */
/* the arguments must not have side effects */ /* the arguments must not have side effects */
/* =========================================================================== /* ===========================================================================
@@ -431,7 +430,6 @@ local void init_block(s)
#define SMALLEST 1 #define SMALLEST 1
/* Index within the heap array of least frequent node in the Huffman tree */ /* Index within the heap array of least frequent node in the Huffman tree */
/* =========================================================================== /* ===========================================================================
* Remove the smallest element from the heap and recreate the heap with * Remove the smallest element from the heap and recreate the heap with
* one less element. Updates heap and heap_len. * one less element. Updates heap and heap_len.

1
lib/zlib/zutil.h
View File

@@ -114,7 +114,6 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
# define Tracecv(c,x) # define Tracecv(c,x)
#endif #endif
voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
void zcfree OF((voidpf opaque, voidpf ptr, unsigned size)); void zcfree OF((voidpf opaque, voidpf ptr, unsigned size));

9
lib/zstd/common/bitstream.h
View File

@@ -28,7 +28,6 @@
#include "debug.h" /* assert(), DEBUGLOG(), RAWLOG() */ #include "debug.h" /* assert(), DEBUGLOG(), RAWLOG() */
#include "error_private.h" /* error codes and messages */ #include "error_private.h" /* error codes and messages */
/*========================================= /*=========================================
* Target specific * Target specific
=========================================*/ =========================================*/
@@ -37,7 +36,6 @@
#define STREAM_ACCUMULATOR_MIN_64 57 #define STREAM_ACCUMULATOR_MIN_64 57
#define STREAM_ACCUMULATOR_MIN ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64)) #define STREAM_ACCUMULATOR_MIN ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))
/*-****************************************** /*-******************************************
* bitStream encoding API (write forward) * bitStream encoding API (write forward)
********************************************/ ********************************************/
@@ -75,7 +73,6 @@ MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
* If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable) * If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)
*/ */
/*-******************************************** /*-********************************************
* bitStream decoding API (read backward) * bitStream decoding API (read backward)
**********************************************/ **********************************************/
@@ -98,7 +95,6 @@ MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD); MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD); MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
/* Start by invoking BIT_initDStream(). /* Start by invoking BIT_initDStream().
* A chunk of the bitStream is then stored into a local register. * A chunk of the bitStream is then stored into a local register.
* Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t). * Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).
@@ -109,7 +105,6 @@ MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
* Checking if DStream has reached its end can be performed with BIT_endOfDStream(). * Checking if DStream has reached its end can be performed with BIT_endOfDStream().
*/ */
/*-**************************************** /*-****************************************
* unsafe API * unsafe API
******************************************/ ******************************************/
@@ -122,8 +117,6 @@ MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits); MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
/* faster, but works only if nbBits >= 1 */ /* faster, but works only if nbBits >= 1 */
/*-************************************************************** /*-**************************************************************
* Internal functions * Internal functions
****************************************************************/ ****************************************************************/
@@ -245,7 +238,6 @@ MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0); return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
} }
/*-******************************************************** /*-********************************************************
* bitStream decoding * bitStream decoding
**********************************************************/ **********************************************************/
@@ -442,5 +434,4 @@ MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8)); return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
} }
#endif /* BITSTREAM_H_MODULE */ #endif /* BITSTREAM_H_MODULE */

4
lib/zstd/common/compiler.h
View File

@@ -70,7 +70,6 @@
/* force no inlining */ /* force no inlining */
#define FORCE_NOINLINE static __attribute__((__noinline__)) #define FORCE_NOINLINE static __attribute__((__noinline__))
/* target attribute */ /* target attribute */
#define TARGET_ATTRIBUTE(target) __attribute__((__target__(target))) #define TARGET_ATTRIBUTE(target) __attribute__((__target__(target)))
@@ -135,7 +134,6 @@
/*Like DYNAMIC_BMI2 but for compile time determination of BMI2 support*/ /*Like DYNAMIC_BMI2 but for compile time determination of BMI2 support*/
/* compile time determination of SIMD support */ /* compile time determination of SIMD support */
/* C-language Attributes are added in C23. */ /* C-language Attributes are added in C23. */
@@ -179,6 +177,4 @@
* Sanitizer * Sanitizer
*****************************************************************/ *****************************************************************/
#endif /* ZSTD_COMPILER_H */ #endif /* ZSTD_COMPILER_H */

1
lib/zstd/common/cpu.h
View File

@@ -18,7 +18,6 @@
#include "mem.h" #include "mem.h"
typedef struct { typedef struct {
U32 f1c; U32 f1c;
U32 f1d; U32 f1d;

1
lib/zstd/common/debug.c
View File

@@ -12,7 +12,6 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
****************************************************************** */ ****************************************************************** */
/* /*
* This module only hosts one global variable * This module only hosts one global variable
* which can be used to dynamically influence the verbosity of traces, * which can be used to dynamically influence the verbosity of traces,

7
lib/zstd/common/debug.h
View File

@@ -12,7 +12,6 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
****************************************************************** */ ****************************************************************** */
/* /*
* The purpose of this header is to enable debug functions. * The purpose of this header is to enable debug functions.
* They regroup assert(), DEBUGLOG() and RAWLOG() for run-time, * They regroup assert(), DEBUGLOG() and RAWLOG() for run-time,
@@ -32,14 +31,11 @@
#ifndef DEBUG_H_12987983217 #ifndef DEBUG_H_12987983217
#define DEBUG_H_12987983217 #define DEBUG_H_12987983217
/* static assert is triggered at compile time, leaving no runtime artefact. /* static assert is triggered at compile time, leaving no runtime artefact.
* static assert only works with compile-time constants. * static assert only works with compile-time constants.
* Also, this variant can only be used inside a function. */ * Also, this variant can only be used inside a function. */
#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1]) #define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])
/* DEBUGLEVEL is expected to be defined externally, /* DEBUGLEVEL is expected to be defined externally,
* typically through compiler command line. * typically through compiler command line.
* Value must be a number. */ * Value must be a number. */
@@ -47,7 +43,6 @@
# define DEBUGLEVEL 0 # define DEBUGLEVEL 0
#endif #endif
/* recommended values for DEBUGLEVEL : /* recommended values for DEBUGLEVEL :
* 0 : release mode, no debug, all run-time checks disabled * 0 : release mode, no debug, all run-time checks disabled
* 1 : enables assert() only, no display * 1 : enables assert() only, no display
@@ -87,6 +82,4 @@ extern int g_debuglevel; /* the variable is only declared,
# define DEBUGLOG(l, ...) {} /* disabled */ # define DEBUGLOG(l, ...) {} /* disabled */
#endif #endif
#endif /* DEBUG_H_12987983217 */ #endif /* DEBUG_H_12987983217 */

4
lib/zstd/common/entropy_common.c
View File

@@ -22,11 +22,9 @@
#define HUF_STATIC_LINKING_ONLY /* HUF_TABLELOG_ABSOLUTEMAX */ #define HUF_STATIC_LINKING_ONLY /* HUF_TABLELOG_ABSOLUTEMAX */
#include "huf.h" #include "huf.h"
/*=== Version ===*/ /*=== Version ===*/
unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; } unsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; }
/*=== Error Management ===*/ /*=== Error Management ===*/
unsigned FSE_isError(size_t code) { return ERR_isError(code); } unsigned FSE_isError(size_t code) { return ERR_isError(code); }
const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); } const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }
@@ -34,7 +32,6 @@ const char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }
unsigned HUF_isError(size_t code) { return ERR_isError(code); } unsigned HUF_isError(size_t code) { return ERR_isError(code); }
const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); } const char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }
/*-************************************************************** /*-**************************************************************
* FSE NCount encoding-decoding * FSE NCount encoding-decoding
****************************************************************/ ****************************************************************/
@@ -240,7 +237,6 @@ size_t FSE_readNCount(
return FSE_readNCount_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize, /* bmi2 */ 0); return FSE_readNCount_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize, /* bmi2 */ 0);
} }
/*! HUF_readStats() : /*! HUF_readStats() :
Read compact Huffman tree, saved by HUF_writeCTable(). Read compact Huffman tree, saved by HUF_writeCTable().
`huffWeight` is destination buffer. `huffWeight` is destination buffer.

7
lib/zstd/common/error_private.h
View File

@@ -13,8 +13,6 @@
#ifndef ERROR_H_MODULE #ifndef ERROR_H_MODULE
#define ERROR_H_MODULE #define ERROR_H_MODULE
/* **************************************** /* ****************************************
* Dependencies * Dependencies
******************************************/ ******************************************/
@@ -23,20 +21,17 @@
#include "debug.h" #include "debug.h"
#include "zstd_deps.h" /* size_t */ #include "zstd_deps.h" /* size_t */
/* **************************************** /* ****************************************
* Compiler-specific * Compiler-specific
******************************************/ ******************************************/
#define ERR_STATIC static __attribute__((unused)) #define ERR_STATIC static __attribute__((unused))
/*-**************************************** /*-****************************************
* Customization (error_public.h) * Customization (error_public.h)
******************************************/ ******************************************/
typedef ZSTD_ErrorCode ERR_enum; typedef ZSTD_ErrorCode ERR_enum;
#define PREFIX(name) ZSTD_error_##name #define PREFIX(name) ZSTD_error_##name
/*-**************************************** /*-****************************************
* Error codes handling * Error codes handling
******************************************/ ******************************************/
@@ -52,7 +47,6 @@ ERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) retu
#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e #define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
#define CHECK_F(f) { CHECK_V_F(_var_err__, f); } #define CHECK_F(f) { CHECK_V_F(_var_err__, f); }
/*-**************************************** /*-****************************************
* Error Strings * Error Strings
******************************************/ ******************************************/
@@ -141,5 +135,4 @@ void _force_has_format_string(const char *format, ...) {
} \ } \
} while(0); } while(0);
#endif /* ERROR_H_MODULE */ #endif /* ERROR_H_MODULE */

24
lib/zstd/common/fse.h
View File

@@ -12,17 +12,14 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
****************************************************************** */ ****************************************************************** */
#ifndef FSE_H #ifndef FSE_H
#define FSE_H #define FSE_H
/*-***************************************** /*-*****************************************
* Dependencies * Dependencies
******************************************/ ******************************************/
#include "zstd_deps.h" /* size_t, ptrdiff_t */ #include "zstd_deps.h" /* size_t, ptrdiff_t */
/*-***************************************** /*-*****************************************
* FSE_PUBLIC_API : control library symbols visibility * FSE_PUBLIC_API : control library symbols visibility
******************************************/ ******************************************/
@@ -49,7 +46,6 @@
#define FSE_VERSION_NUMBER (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE) #define FSE_VERSION_NUMBER (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)
FSE_PUBLIC_API unsigned FSE_versionNumber(void); /*< library version number; to be used when checking dll version */ FSE_PUBLIC_API unsigned FSE_versionNumber(void); /*< library version number; to be used when checking dll version */
/*-**************************************** /*-****************************************
* FSE simple functions * FSE simple functions
******************************************/ ******************************************/
@@ -77,7 +73,6 @@ FSE_PUBLIC_API size_t FSE_compress(void* dst, size_t dstCapacity,
FSE_PUBLIC_API size_t FSE_decompress(void* dst, size_t dstCapacity, FSE_PUBLIC_API size_t FSE_decompress(void* dst, size_t dstCapacity,
const void* cSrc, size_t cSrcSize); const void* cSrc, size_t cSrcSize);
/*-***************************************** /*-*****************************************
* Tool functions * Tool functions
******************************************/ ******************************************/
@@ -87,7 +82,6 @@ FSE_PUBLIC_API size_t FSE_compressBound(size_t size); /* maximum compresse
FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */ FSE_PUBLIC_API unsigned FSE_isError(size_t code); /* tells if a return value is an error code */
FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error code string (useful for debugging) */ FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error code string (useful for debugging) */
/*-***************************************** /*-*****************************************
* FSE advanced functions * FSE advanced functions
******************************************/ ******************************************/
@@ -101,7 +95,6 @@ FSE_PUBLIC_API const char* FSE_getErrorName(size_t code); /* provides error co
*/ */
FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog); FSE_PUBLIC_API size_t FSE_compress2 (void* dst, size_t dstSize, const void* src, size_t srcSize, unsigned maxSymbolValue, unsigned tableLog);
/*-***************************************** /*-*****************************************
* FSE detailed API * FSE detailed API
******************************************/ ******************************************/
@@ -219,7 +212,6 @@ If it returns '0', compressed data could not fit into 'dst'.
If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()). If there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).
*/ */
/* *** DECOMPRESSION *** */ /* *** DECOMPRESSION *** */
/*! FSE_readNCount(): /*! FSE_readNCount():
@@ -292,7 +284,6 @@ If there is an error, the function will return an error code, which can be teste
/* *** Dependency *** */ /* *** Dependency *** */
#include "bitstream.h" #include "bitstream.h"
/* ***************************************** /* *****************************************
* Static allocation * Static allocation
*******************************************/ *******************************************/
@@ -309,7 +300,6 @@ If there is an error, the function will return an error code, which can be teste
#define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue) (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable)) #define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue) (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))
#define FSE_DTABLE_SIZE(maxTableLog) (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable)) #define FSE_DTABLE_SIZE(maxTableLog) (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))
/* ***************************************** /* *****************************************
* FSE advanced API * FSE advanced API
***************************************** */ ***************************************** */
@@ -397,7 +387,6 @@ FSE_CTable ct; // Provided by FSE_buildCTable()
BIT_CStream_t bitStream; // bitStream tracking structure BIT_CStream_t bitStream; // bitStream tracking structure
FSE_CState_t state; // State tracking structure (can have several) FSE_CState_t state; // State tracking structure (can have several)
The first thing to do is to init bitStream and state. The first thing to do is to init bitStream and state.
size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize); size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize);
FSE_initCState(&state, ct); FSE_initCState(&state, ct);
@@ -427,7 +416,6 @@ If there is an error, it returns an errorCode (which can be tested using FSE_isE
size_t size = BIT_closeCStream(&bitStream); size_t size = BIT_closeCStream(&bitStream);
*/ */
/* ***************************************** /* *****************************************
* FSE symbol decompression API * FSE symbol decompression API
*******************************************/ *******************************************/
@@ -436,7 +424,6 @@ typedef struct {
const void* table; /* precise table may vary, depending on U16 */ const void* table; /* precise table may vary, depending on U16 */
} FSE_DState_t; } FSE_DState_t;
static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt); static void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);
static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); static unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
@@ -492,14 +479,12 @@ Check also the states. There might be some symbols left there, if some high prob
FSE_endOfDState(&DState); FSE_endOfDState(&DState);
*/ */
/* ***************************************** /* *****************************************
* FSE unsafe API * FSE unsafe API
*******************************************/ *******************************************/
static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD); static unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);
/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */ /* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */
/* ***************************************** /* *****************************************
* Implementation of inlined functions * Implementation of inlined functions
*******************************************/ *******************************************/
@@ -519,7 +504,6 @@ MEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)
statePtr->stateLog = tableLog; statePtr->stateLog = tableLog;
} }
/*! FSE_initCState2() : /*! FSE_initCState2() :
* Same as FSE_initCState(), but the first symbol to include (which will be the last to be read) * Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)
* uses the smallest state value possible, saving the cost of this symbol */ * uses the smallest state value possible, saving the cost of this symbol */
@@ -549,7 +533,6 @@ MEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePt
BIT_flushBits(bitC); BIT_flushBits(bitC);
} }
/* FSE_getMaxNbBits() : /* FSE_getMaxNbBits() :
* Approximate maximum cost of a symbol, in bits. * Approximate maximum cost of a symbol, in bits.
* Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2) * Fractional get rounded up (i.e : a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)
@@ -582,7 +565,6 @@ MEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValu
} }
} }
/* ====== Decompression ====== */ /* ====== Decompression ====== */
typedef struct { typedef struct {
@@ -649,8 +631,6 @@ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
return DStatePtr->state == 0; return DStatePtr->state == 0;
} }
#ifndef FSE_COMMONDEFS_ONLY #ifndef FSE_COMMONDEFS_ONLY
/* ************************************************************** /* **************************************************************
@@ -685,10 +665,8 @@ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
#define FSE_FUNCTION_EXTENSION #define FSE_FUNCTION_EXTENSION
#define FSE_DECODE_TYPE FSE_decode_t #define FSE_DECODE_TYPE FSE_decode_t
#endif /* !FSE_COMMONDEFS_ONLY */ #endif /* !FSE_COMMONDEFS_ONLY */
/* *************************************************************** /* ***************************************************************
* Constants * Constants
*****************************************************************/ *****************************************************************/
@@ -705,7 +683,5 @@ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
#define FSE_TABLESTEP(tableSize) (((tableSize)>>1) + ((tableSize)>>3) + 3) #define FSE_TABLESTEP(tableSize) (((tableSize)>>1) + ((tableSize)>>3) + 3)
#endif /* FSE_STATIC_LINKING_ONLY */ #endif /* FSE_STATIC_LINKING_ONLY */

12
lib/zstd/common/fse_decompress.c
View File

@@ -12,7 +12,6 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
****************************************************************** */ ****************************************************************** */
/* ************************************************************** /* **************************************************************
* Includes * Includes
****************************************************************/ ****************************************************************/
@@ -25,14 +24,12 @@
#define ZSTD_DEPS_NEED_MALLOC #define ZSTD_DEPS_NEED_MALLOC
#include "zstd_deps.h" #include "zstd_deps.h"
/* ************************************************************** /* **************************************************************
* Error Management * Error Management
****************************************************************/ ****************************************************************/
#define FSE_isError ERR_isError #define FSE_isError ERR_isError
#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) /* use only *after* variable declarations */ #define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) /* use only *after* variable declarations */
/* ************************************************************** /* **************************************************************
* Templates * Templates
****************************************************************/ ****************************************************************/
@@ -55,7 +52,6 @@
#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y) #define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)
#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y) #define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)
/* Function templates */ /* Function templates */
FSE_DTable* FSE_createDTable (unsigned tableLog) FSE_DTable* FSE_createDTable (unsigned tableLog)
{ {
@@ -178,7 +174,6 @@ size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsi
return FSE_buildDTable_internal(dt, normalizedCounter, maxSymbolValue, tableLog, workSpace, wkspSize); return FSE_buildDTable_internal(dt, normalizedCounter, maxSymbolValue, tableLog, workSpace, wkspSize);
} }
#ifndef FSE_COMMONDEFS_ONLY #ifndef FSE_COMMONDEFS_ONLY
/*-******************************************************* /*-*******************************************************
@@ -201,7 +196,6 @@ size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
return 0; return 0;
} }
size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits) size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
{ {
void* ptr = dt; void* ptr = dt;
@@ -290,7 +284,6 @@ FORCE_INLINE_TEMPLATE size_t FSE_decompress_usingDTable_generic(
return op-ostart; return op-ostart;
} }
size_t FSE_decompress_usingDTable(void* dst, size_t originalSize, size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
const FSE_DTable* dt) const FSE_DTable* dt)
@@ -304,7 +297,6 @@ size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,
return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0); return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);
} }
size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize) size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)
{ {
return FSE_decompress_wksp_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, /* bmi2 */ 0); return FSE_decompress_wksp_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, /* bmi2 */ 0);
@@ -315,7 +307,6 @@ typedef struct {
FSE_DTable dtable[1]; /* Dynamically sized */ FSE_DTable dtable[1]; /* Dynamically sized */
} FSE_DecompressWksp; } FSE_DecompressWksp;
FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body( FORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
@@ -382,9 +373,6 @@ size_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc,
return FSE_decompress_wksp_body_default(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize); return FSE_decompress_wksp_body_default(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);
} }
typedef FSE_DTable DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)]; typedef FSE_DTable DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];
#endif /* FSE_COMMONDEFS_ONLY */ #endif /* FSE_COMMONDEFS_ONLY */

10
lib/zstd/common/huf.h
View File

@@ -12,14 +12,12 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
****************************************************************** */ ****************************************************************** */
#ifndef HUF_H_298734234 #ifndef HUF_H_298734234
#define HUF_H_298734234 #define HUF_H_298734234
/* *** Dependencies *** */ /* *** Dependencies *** */
#include "zstd_deps.h" /* size_t */ #include "zstd_deps.h" /* size_t */
/* *** library symbols visibility *** */ /* *** library symbols visibility *** */
/* Note : when linking with -fvisibility=hidden on gcc, or by default on Visual, /* Note : when linking with -fvisibility=hidden on gcc, or by default on Visual,
* HUF symbols remain "private" (internal symbols for library only). * HUF symbols remain "private" (internal symbols for library only).
@@ -34,7 +32,6 @@
# define HUF_PUBLIC_API # define HUF_PUBLIC_API
#endif #endif
/* ========================== */ /* ========================== */
/* *** simple functions *** */ /* *** simple functions *** */
/* ========================== */ /* ========================== */
@@ -64,7 +61,6 @@ HUF_PUBLIC_API size_t HUF_compress(void* dst, size_t dstCapacity,
HUF_PUBLIC_API size_t HUF_decompress(void* dst, size_t originalSize, HUF_PUBLIC_API size_t HUF_decompress(void* dst, size_t originalSize,
const void* cSrc, size_t cSrcSize); const void* cSrc, size_t cSrcSize);
/* *** Tool functions *** */ /* *** Tool functions *** */
#define HUF_BLOCKSIZE_MAX (128 * 1024) /*< maximum input size for a single block compressed with HUF_compress */ #define HUF_BLOCKSIZE_MAX (128 * 1024) /*< maximum input size for a single block compressed with HUF_compress */
HUF_PUBLIC_API size_t HUF_compressBound(size_t size); /*< maximum compressed size (worst case) */ HUF_PUBLIC_API size_t HUF_compressBound(size_t size); /*< maximum compressed size (worst case) */
@@ -73,7 +69,6 @@ HUF_PUBLIC_API size_t HUF_compressBound(size_t size); /*< maximum compressed s
HUF_PUBLIC_API unsigned HUF_isError(size_t code); /*< tells if a return value is an error code */ HUF_PUBLIC_API unsigned HUF_isError(size_t code); /*< tells if a return value is an error code */
HUF_PUBLIC_API const char* HUF_getErrorName(size_t code); /*< provides error code string (useful for debugging) */ HUF_PUBLIC_API const char* HUF_getErrorName(size_t code); /*< provides error code string (useful for debugging) */
/* *** Advanced function *** */ /* *** Advanced function *** */
/* HUF_compress2() : /* HUF_compress2() :
@@ -111,7 +106,6 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
#define FSE_STATIC_LINKING_ONLY #define FSE_STATIC_LINKING_ONLY
#include "fse.h" #include "fse.h"
/* *** Constants *** */ /* *** Constants *** */
#define HUF_TABLELOG_MAX 12 /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_TABLELOG_ABSOLUTEMAX */ #define HUF_TABLELOG_MAX 12 /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_TABLELOG_ABSOLUTEMAX */
#define HUF_TABLELOG_DEFAULT 11 /* default tableLog value when none specified */ #define HUF_TABLELOG_DEFAULT 11 /* default tableLog value when none specified */
@@ -122,7 +116,6 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity,
# error "HUF_TABLELOG_MAX is too large !" # error "HUF_TABLELOG_MAX is too large !"
#endif #endif
/* **************************************** /* ****************************************
* Static allocation * Static allocation
******************************************/ ******************************************/
@@ -147,7 +140,6 @@ typedef U32 HUF_DTable;
#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \ #define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \
HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) } HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }
/* **************************************** /* ****************************************
* Advanced decompression functions * Advanced decompression functions
******************************************/ ******************************************/
@@ -166,7 +158,6 @@ size_t HUF_decompress4X2_DCtx(HUF_DTable* dctx, void* dst, size_t dstSize, const
size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /*< double-symbols decoder */ size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize); /*< double-symbols decoder */
#endif #endif
/* **************************************** /* ****************************************
* HUF detailed API * HUF detailed API
* ****************************************/ * ****************************************/
@@ -293,7 +284,6 @@ size_t HUF_decompress4X1_usingDTable(void* dst, size_t maxDstSize, const void* c
size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable); size_t HUF_decompress4X2_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable);
#endif #endif
/* ====================== */ /* ====================== */
/* single stream variants */ /* single stream variants */
/* ====================== */ /* ====================== */

1
lib/zstd/common/portability_macros.h
View File

@@ -20,7 +20,6 @@
* *
*/ */
/* compat. with non-clang compilers */ /* compat. with non-clang compilers */
#ifndef __has_attribute #ifndef __has_attribute
#define __has_attribute(x) 0 #define __has_attribute(x) 0

6
lib/zstd/common/zstd_common.c
View File

@@ -8,8 +8,6 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
/*-************************************* /*-*************************************
* Dependencies * Dependencies
***************************************/ ***************************************/
@@ -18,7 +16,6 @@
#include "error_private.h" #include "error_private.h"
#include "zstd_internal.h" #include "zstd_internal.h"
/*-**************************************** /*-****************************************
* Version * Version
******************************************/ ******************************************/
@@ -26,7 +23,6 @@ unsigned ZSTD_versionNumber(void) { return ZSTD_VERSION_NUMBER; }
const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; } const char* ZSTD_versionString(void) { return ZSTD_VERSION_STRING; }
/*-**************************************** /*-****************************************
* ZSTD Error Management * ZSTD Error Management
******************************************/ ******************************************/
@@ -48,8 +44,6 @@ ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }
* provides error code string from enum */ * provides error code string from enum */
const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); } const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); }
/*=************************************************************** /*=**************************************************************
* Custom allocator * Custom allocator
****************************************************************/ ****************************************************************/

9
lib/zstd/common/zstd_internal.h
View File

@@ -33,14 +33,12 @@
#include <linux/xxhash.h> /* XXH_reset, update, digest */ #include <linux/xxhash.h> /* XXH_reset, update, digest */
#define ZSTD_TRACE 0 #define ZSTD_TRACE 0
/* ---- static assert (debug) --- */ /* ---- static assert (debug) --- */
#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c) #define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)
#define ZSTD_isError ERR_isError /* for inlining */ #define ZSTD_isError ERR_isError /* for inlining */
#define FSE_isError ERR_isError #define FSE_isError ERR_isError
#define HUF_isError ERR_isError #define HUF_isError ERR_isError
/*-************************************* /*-*************************************
* shared macros * shared macros
***************************************/ ***************************************/
@@ -50,7 +48,6 @@
#define MAX(a,b) ((a)>(b) ? (a) : (b)) #define MAX(a,b) ((a)>(b) ? (a) : (b))
#define BOUNDED(min,val,max) (MAX(min,MIN(val,max))) #define BOUNDED(min,val,max) (MAX(min,MIN(val,max)))
/*-************************************* /*-*************************************
* Common constants * Common constants
***************************************/ ***************************************/
@@ -155,7 +152,6 @@ static UNUSED_ATTR const S16 OF_defaultNorm[DefaultMaxOff+1] = {
#define OF_DEFAULTNORMLOG 5 /* for static allocation */ #define OF_DEFAULTNORMLOG 5 /* for static allocation */
static UNUSED_ATTR const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG; static UNUSED_ATTR const U32 OF_defaultNormLog = OF_DEFAULTNORMLOG;
/*-******************************************* /*-*******************************************
* Shared functions to include for inlining * Shared functions to include for inlining
*********************************************/ *********************************************/
@@ -269,7 +265,6 @@ typedef enum {
ZSTD_bm_stable = 1 /* ZSTD_inBuffer/ZSTD_outBuffer is stable */ ZSTD_bm_stable = 1 /* ZSTD_inBuffer/ZSTD_outBuffer is stable */
} ZSTD_bufferMode_e; } ZSTD_bufferMode_e;
/*-******************************************* /*-*******************************************
* Private declarations * Private declarations
*********************************************/ *********************************************/
@@ -349,7 +344,6 @@ void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem);
void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem); void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem);
void ZSTD_customFree(void* ptr, ZSTD_customMem customMem); void ZSTD_customFree(void* ptr, ZSTD_customMem customMem);
MEM_STATIC U32 ZSTD_highbit32(U32 val) /* compress, dictBuilder, decodeCorpus */ MEM_STATIC U32 ZSTD_highbit32(U32 val) /* compress, dictBuilder, decodeCorpus */
{ {
assert(val != 0); assert(val != 0);
@@ -404,14 +398,12 @@ MEM_STATIC unsigned ZSTD_countTrailingZeros(size_t val)
} }
} }
/* ZSTD_invalidateRepCodes() : /* ZSTD_invalidateRepCodes() :
* ensures next compression will not use repcodes from previous block. * ensures next compression will not use repcodes from previous block.
* Note : only works with regular variant; * Note : only works with regular variant;
* do not use with extDict variant ! */ * do not use with extDict variant ! */
void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx); /* zstdmt, adaptive_compression (shouldn't get this definition from here) */ void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx); /* zstdmt, adaptive_compression (shouldn't get this definition from here) */
typedef struct { typedef struct {
blockType_e blockType; blockType_e blockType;
U32 lastBlock; U32 lastBlock;
@@ -439,5 +431,4 @@ MEM_STATIC int ZSTD_cpuSupportsBmi2(void)
return ZSTD_cpuid_bmi1(cpuid) && ZSTD_cpuid_bmi2(cpuid); return ZSTD_cpuid_bmi1(cpuid) && ZSTD_cpuid_bmi2(cpuid);
} }
#endif /* ZSTD_CCOMMON_H_MODULE */ #endif /* ZSTD_CCOMMON_H_MODULE */

17
lib/zstd/decompress/huf_decompress.c
View File

@@ -69,14 +69,12 @@
****************************************************************/ ****************************************************************/
#define HUF_isError ERR_isError #define HUF_isError ERR_isError
/* ************************************************************** /* **************************************************************
* Byte alignment for workSpace management * Byte alignment for workSpace management
****************************************************************/ ****************************************************************/
#define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1) #define HUF_ALIGN(x, a) HUF_ALIGN_MASK((x), (a) - 1)
#define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask)) #define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
/* ************************************************************** /* **************************************************************
* BMI2 Variant Wrappers * BMI2 Variant Wrappers
****************************************************************/ ****************************************************************/
@@ -121,7 +119,6 @@
#endif #endif
/*-***************************/ /*-***************************/
/* generic DTableDesc */ /* generic DTableDesc */
/*-***************************/ /*-***************************/
@@ -268,7 +265,6 @@ static size_t HUF_initRemainingDStream(BIT_DStream_t* bit, HUF_DecompressAsmArgs
} }
#endif #endif
#ifndef HUF_FORCE_DECOMPRESS_X2 #ifndef HUF_FORCE_DECOMPRESS_X2
/*-***************************/ /*-***************************/
@@ -329,7 +325,6 @@ typedef struct {
BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1]; BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];
} HUF_ReadDTableX1_Workspace; } HUF_ReadDTableX1_Workspace;
size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize) size_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize)
{ {
return HUF_readDTableX1_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0); return HUF_readDTableX1_wksp_bmi2(DTable, src, srcSize, workSpace, wkspSize, /* bmi2 */ 0);
@@ -353,7 +348,6 @@ size_t HUF_readDTableX1_wksp_bmi2(HUF_DTable* DTable, const void* src, size_t sr
iSize = HUF_readStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, srcSize, wksp->statsWksp, sizeof(wksp->statsWksp), bmi2); iSize = HUF_readStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, srcSize, wksp->statsWksp, sizeof(wksp->statsWksp), bmi2);
if (HUF_isError(iSize)) return iSize; if (HUF_isError(iSize)) return iSize;
/* Table header */ /* Table header */
{ DTableDesc dtd = HUF_getDTableDesc(DTable); { DTableDesc dtd = HUF_getDTableDesc(DTable);
U32 const maxTableLog = dtd.maxTableLog + 1; U32 const maxTableLog = dtd.maxTableLog + 1;
@@ -745,7 +739,6 @@ static size_t HUF_decompress4X1_usingDTable_internal(void* dst, size_t dstSize,
#endif #endif
} }
size_t HUF_decompress1X1_usingDTable( size_t HUF_decompress1X1_usingDTable(
void* dst, size_t dstSize, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
@@ -770,7 +763,6 @@ size_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0); return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
} }
size_t HUF_decompress4X1_usingDTable( size_t HUF_decompress4X1_usingDTable(
void* dst, size_t dstSize, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
@@ -802,10 +794,8 @@ size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0); return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, 0);
} }
#endif /* HUF_FORCE_DECOMPRESS_X2 */ #endif /* HUF_FORCE_DECOMPRESS_X2 */
#ifndef HUF_FORCE_DECOMPRESS_X1 #ifndef HUF_FORCE_DECOMPRESS_X1
/* *************************/ /* *************************/
@@ -1130,7 +1120,6 @@ size_t HUF_readDTableX2_wksp_bmi2(HUF_DTable* DTable,
return iSize; return iSize;
} }
FORCE_INLINE_TEMPLATE U32 FORCE_INLINE_TEMPLATE U32
HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog) HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
{ {
@@ -1477,7 +1466,6 @@ size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0); return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
} }
size_t HUF_decompress4X2_usingDTable( size_t HUF_decompress4X2_usingDTable(
void* dst, size_t dstSize, void* dst, size_t dstSize,
const void* cSrc, size_t cSrcSize, const void* cSrc, size_t cSrcSize,
@@ -1510,10 +1498,8 @@ size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0); return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, /* bmi2 */ 0);
} }
#endif /* HUF_FORCE_DECOMPRESS_X1 */ #endif /* HUF_FORCE_DECOMPRESS_X1 */
/* ***********************************/ /* ***********************************/
/* Universal decompression selectors */ /* Universal decompression selectors */
/* ***********************************/ /* ***********************************/
@@ -1556,7 +1542,6 @@ size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
#endif #endif
} }
#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2) #if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t; typedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;
static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */] = static const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */] =
@@ -1610,7 +1595,6 @@ U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
#endif #endif
} }
size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
size_t dstSize, const void* cSrc, size_t dstSize, const void* cSrc,
size_t cSrcSize, void* workSpace, size_t cSrcSize, void* workSpace,
@@ -1667,7 +1651,6 @@ size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
} }
} }
size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2) size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
{ {
DTableDesc const dtd = HUF_getDTableDesc(DTable); DTableDesc const dtd = HUF_getDTableDesc(DTable);

7
lib/zstd/decompress/zstd_ddict.c
View File

@@ -24,9 +24,6 @@
#include "zstd_decompress_internal.h" #include "zstd_decompress_internal.h"
#include "zstd_ddict.h" #include "zstd_ddict.h"
/*-******************************************************* /*-*******************************************************
* Types * Types
*********************************************************/ *********************************************************/
@@ -82,7 +79,6 @@ void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
} }
} }
static size_t static size_t
ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict, ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
ZSTD_dictContentType_e dictContentType) ZSTD_dictContentType_e dictContentType)
@@ -113,7 +109,6 @@ ZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,
return 0; return 0;
} }
static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict, static size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,
const void* dict, size_t dictSize, const void* dict, size_t dictSize,
ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictLoadMethod_e dictLoadMethod,
@@ -180,7 +175,6 @@ ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize
return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator); return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);
} }
const ZSTD_DDict* ZSTD_initStaticDDict( const ZSTD_DDict* ZSTD_initStaticDDict(
void* sBuffer, size_t sBufferSize, void* sBuffer, size_t sBufferSize,
const void* dict, size_t dictSize, const void* dict, size_t dictSize,
@@ -205,7 +199,6 @@ const ZSTD_DDict* ZSTD_initStaticDDict(
return ddict; return ddict;
} }
size_t ZSTD_freeDDict(ZSTD_DDict* ddict) size_t ZSTD_freeDDict(ZSTD_DDict* ddict)
{ {
if (ddict==NULL) return 0; /* support free on NULL */ if (ddict==NULL) return 0; /* support free on NULL */

4
lib/zstd/decompress/zstd_ddict.h
View File

@@ -8,7 +8,6 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
#ifndef ZSTD_DDICT_H #ifndef ZSTD_DDICT_H
#define ZSTD_DDICT_H #define ZSTD_DDICT_H
@@ -18,7 +17,6 @@
#include "../common/zstd_deps.h" /* size_t */ #include "../common/zstd_deps.h" /* size_t */
#include <linux/zstd.h> /* ZSTD_DDict, and several public functions */ #include <linux/zstd.h> /* ZSTD_DDict, and several public functions */
/*-******************************************************* /*-*******************************************************
* Interface * Interface
*********************************************************/ *********************************************************/
@@ -39,6 +37,4 @@ size_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict);
void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict); void ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);
#endif /* ZSTD_DDICT_H */ #endif /* ZSTD_DDICT_H */

26
lib/zstd/decompress/zstd_decompress.c
View File

@@ -8,7 +8,6 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
/* *************************************************************** /* ***************************************************************
* Tuning parameters * Tuning parameters
*****************************************************************/ *****************************************************************/
@@ -48,7 +47,6 @@
# define ZSTD_NO_FORWARD_PROGRESS_MAX 16 # define ZSTD_NO_FORWARD_PROGRESS_MAX 16
#endif #endif
/*-******************************************************* /*-*******************************************************
* Dependencies * Dependencies
*********************************************************/ *********************************************************/
@@ -64,9 +62,6 @@
#include "zstd_ddict.h" /* ZSTD_DDictDictContent */ #include "zstd_ddict.h" /* ZSTD_DDictDictContent */
#include "zstd_decompress_block.h" /* ZSTD_decompressBlock_internal */ #include "zstd_decompress_block.h" /* ZSTD_decompressBlock_internal */
/* *********************************** /* ***********************************
* Multiple DDicts Hashset internals * * Multiple DDicts Hashset internals *
*************************************/ *************************************/
@@ -220,7 +215,6 @@ size_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)
size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); } size_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }
static size_t ZSTD_startingInputLength(ZSTD_format_e format) static size_t ZSTD_startingInputLength(ZSTD_format_e format)
{ {
size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format); size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format);
@@ -353,7 +347,6 @@ static void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {
} }
} }
/*-************************************************************* /*-*************************************************************
* Frame header decoding * Frame header decoding
***************************************************************/ ***************************************************************/
@@ -415,7 +408,6 @@ size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)
return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1); return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);
} }
/* ZSTD_getFrameHeader_advanced() : /* ZSTD_getFrameHeader_advanced() :
* decode Frame Header, or require larger `srcSize`. * decode Frame Header, or require larger `srcSize`.
* note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless * note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless
@@ -639,7 +631,6 @@ unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret; return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;
} }
/* ZSTD_decodeFrameHeader() : /* ZSTD_decodeFrameHeader() :
* `headerSize` must be the size provided by ZSTD_frameHeaderSize(). * `headerSize` must be the size provided by ZSTD_frameHeaderSize().
* If multiple DDict references are enabled, also will choose the correct DDict to use. * If multiple DDict references are enabled, also will choose the correct DDict to use.
@@ -681,7 +672,6 @@ static ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize
ZSTD_frameSizeInfo frameSizeInfo; ZSTD_frameSizeInfo frameSizeInfo;
ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo)); ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));
if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE) if ((srcSize >= ZSTD_SKIPPABLEHEADERSIZE)
&& (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) { && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {
frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize); frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);
@@ -773,7 +763,6 @@ unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)
return bound; return bound;
} }
/*-************************************************************* /*-*************************************************************
* Frame decoding * Frame decoding
***************************************************************/ ***************************************************************/
@@ -788,7 +777,6 @@ size_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSiz
return blockSize; return blockSize;
} }
static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity, static size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,
const void* src, size_t srcSize) const void* src, size_t srcSize)
{ {
@@ -823,7 +811,6 @@ static void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64
(void)streaming; (void)streaming;
} }
/*! ZSTD_decompressFrame() : /*! ZSTD_decompressFrame() :
* @dctx must be properly initialized * @dctx must be properly initialized
* will update *srcPtr and *srcSizePtr, * will update *srcPtr and *srcSizePtr,
@@ -935,7 +922,6 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
while (srcSize >= ZSTD_startingInputLength(dctx->format)) { while (srcSize >= ZSTD_startingInputLength(dctx->format)) {
{ U32 const magicNumber = MEM_readLE32(src); { U32 const magicNumber = MEM_readLE32(src);
DEBUGLOG(4, "reading magic number %08X (expecting %08X)", DEBUGLOG(4, "reading magic number %08X (expecting %08X)",
(unsigned)magicNumber, ZSTD_MAGICNUMBER); (unsigned)magicNumber, ZSTD_MAGICNUMBER);
@@ -994,7 +980,6 @@ size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,
return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL); return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);
} }
static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx) static ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)
{ {
switch (dctx->dictUses) { switch (dctx->dictUses) {
@@ -1017,7 +1002,6 @@ size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const
return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx)); return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));
} }
size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize) size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)
{ {
#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1) #if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)
@@ -1034,7 +1018,6 @@ size_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t sr
#endif #endif
} }
/*-************************************** /*-**************************************
* Advanced Streaming Decompression API * Advanced Streaming Decompression API
* Bufferless and synchronous * Bufferless and synchronous
@@ -1247,7 +1230,6 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
} }
} }
static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize) static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
{ {
dctx->dictEnd = dctx->previousDstEnd; dctx->dictEnd = dctx->previousDstEnd;
@@ -1407,7 +1389,6 @@ size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t
return 0; return 0;
} }
/* ====== ZSTD_DDict ====== */ /* ====== ZSTD_DDict ====== */
size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
@@ -1461,7 +1442,6 @@ unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
return zfp.dictID; return zfp.dictID;
} }
/*! ZSTD_decompress_usingDDict() : /*! ZSTD_decompress_usingDDict() :
* Decompression using a pre-digested Dictionary * Decompression using a pre-digested Dictionary
* Use dictionary without significant overhead. */ * Use dictionary without significant overhead. */
@@ -1476,7 +1456,6 @@ size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,
ddict); ddict);
} }
/*===================================== /*=====================================
* Streaming decompression * Streaming decompression
*====================================*/ *====================================*/
@@ -1502,7 +1481,6 @@ size_t ZSTD_freeDStream(ZSTD_DStream* zds)
return ZSTD_freeDCtx(zds); return ZSTD_freeDCtx(zds);
} }
/* *** Initialization *** */ /* *** Initialization *** */
size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; } size_t ZSTD_DStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
@@ -1546,7 +1524,6 @@ size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSiz
return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent); return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);
} }
/* ZSTD_initDStream_usingDict() : /* ZSTD_initDStream_usingDict() :
* return : expected size, aka ZSTD_startingInputLength(). * return : expected size, aka ZSTD_startingInputLength().
* this function cannot fail */ * this function cannot fail */
@@ -1584,7 +1561,6 @@ size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
return ZSTD_startingInputLength(dctx->format); return ZSTD_startingInputLength(dctx->format);
} }
size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict) size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)
{ {
RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, ""); RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, "");
@@ -1745,7 +1721,6 @@ size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)
return 0; return 0;
} }
size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx) size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
{ {
return ZSTD_sizeof_DCtx(dctx); return ZSTD_sizeof_DCtx(dctx);
@@ -1783,7 +1758,6 @@ size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
return ZSTD_estimateDStreamSize((size_t)zfh.windowSize); return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
} }
/* ***** Decompression ***** */ /* ***** Decompression ***** */
static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize) static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)

18
lib/zstd/decompress/zstd_decompress_block.c
View File

@@ -40,13 +40,11 @@
#error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!" #error "Cannot force the use of the short and the long ZSTD_decompressSequences variants!"
#endif #endif
/*_******************************************************* /*_*******************************************************
* Memory operations * Memory operations
**********************************************************/ **********************************************************/
static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); } static void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }
/*-************************************************************* /*-*************************************************************
* Block decoding * Block decoding
***************************************************************/ ***************************************************************/
@@ -379,7 +377,6 @@ static const ZSTD_seqSymbol OF_defaultDTable[(1<<OF_DEFAULTNORMLOG)+1] = {
{ 0, 25, 5,33554429}, { 0, 24, 5,16777213}, { 0, 25, 5,33554429}, { 0, 24, 5,16777213},
}; /* OF_defaultDTable */ }; /* OF_defaultDTable */
/* Default FSE distribution table for Match Lengths */ /* Default FSE distribution table for Match Lengths */
static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = { static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
{ 1, 1, 1, ML_DEFAULTNORMLOG}, /* header : fastMode, tableLog */ { 1, 1, 1, ML_DEFAULTNORMLOG}, /* header : fastMode, tableLog */
@@ -418,7 +415,6 @@ static const ZSTD_seqSymbol ML_defaultDTable[(1<<ML_DEFAULTNORMLOG)+1] = {
{ 0, 11, 6, 2051}, { 0, 10, 6, 1027}, { 0, 11, 6, 2051}, { 0, 10, 6, 1027},
}; /* ML_defaultDTable */ }; /* ML_defaultDTable */
static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U8 nbAddBits) static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U8 nbAddBits)
{ {
void* ptr = dt; void* ptr = dt;
@@ -435,7 +431,6 @@ static void ZSTD_buildSeqTable_rle(ZSTD_seqSymbol* dt, U32 baseValue, U8 nbAddBi
cell->baseValue = baseValue; cell->baseValue = baseValue;
} }
/* ZSTD_buildFSETable() : /* ZSTD_buildFSETable() :
* generate FSE decoding table for one symbol (ll, ml or off) * generate FSE decoding table for one symbol (ll, ml or off)
* cannot fail if input is valid => * cannot fail if input is valid =>
@@ -454,7 +449,6 @@ void ZSTD_buildFSETable_body(ZSTD_seqSymbol* dt,
BYTE* spread = (BYTE*)(symbolNext + MaxSeq + 1); BYTE* spread = (BYTE*)(symbolNext + MaxSeq + 1);
U32 highThreshold = tableSize - 1; U32 highThreshold = tableSize - 1;
/* Sanity Checks */ /* Sanity Checks */
assert(maxSymbolValue <= MaxSeq); assert(maxSymbolValue <= MaxSeq);
assert(tableLog <= MaxFSELog); assert(tableLog <= MaxFSELog);
@@ -598,7 +592,6 @@ void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
baseValue, nbAdditionalBits, tableLog, wksp, wkspSize); baseValue, nbAdditionalBits, tableLog, wksp, wkspSize);
} }
/*! ZSTD_buildSeqTable() : /*! ZSTD_buildSeqTable() :
* @return : nb bytes read from src, * @return : nb bytes read from src,
* or an error code if it fails */ * or an error code if it fails */
@@ -729,7 +722,6 @@ size_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,
return ip-istart; return ip-istart;
} }
typedef struct { typedef struct {
size_t litLength; size_t litLength;
size_t matchLength; size_t matchLength;
@@ -915,7 +907,6 @@ size_t ZSTD_execSequenceEndSplitLitBuffer(BYTE* op,
const BYTE* const iLitEnd = *litPtr + sequence.litLength; const BYTE* const iLitEnd = *litPtr + sequence.litLength;
const BYTE* match = oLitEnd - sequence.offset; const BYTE* match = oLitEnd - sequence.offset;
/* bounds checks : careful of address space overflow in 32-bit mode */ /* bounds checks : careful of address space overflow in 32-bit mode */
RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer"); RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, "last match must fit within dstBuffer");
RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer"); RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, "try to read beyond literal buffer");
@@ -1133,7 +1124,6 @@ size_t ZSTD_execSequenceSplitLitBuffer(BYTE* op,
return sequenceLength; return sequenceLength;
} }
static void static void
ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt) ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
{ {
@@ -1316,7 +1306,6 @@ MEM_STATIC void ZSTD_assertValidSequence(
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG #ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
FORCE_INLINE_TEMPLATE size_t FORCE_INLINE_TEMPLATE size_t
DONT_VECTORIZE DONT_VECTORIZE
ZSTD_decompressSequences_bodySplitLitBuffer( ZSTD_DCtx* dctx, ZSTD_decompressSequences_bodySplitLitBuffer( ZSTD_DCtx* dctx,
@@ -1841,8 +1830,6 @@ ZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,
} }
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */ #endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
#if DYNAMIC_BMI2 #if DYNAMIC_BMI2
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG #ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG
@@ -1920,7 +1907,6 @@ ZSTD_decompressSequencesSplitLitBuffer(ZSTD_DCtx* dctx, void* dst, size_t maxDst
} }
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */ #endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */
#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT #ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT
/* ZSTD_decompressSequencesLong() : /* ZSTD_decompressSequencesLong() :
* decompression function triggered when a minimum share of offsets is considered "long", * decompression function triggered when a minimum share of offsets is considered "long",
@@ -1944,8 +1930,6 @@ ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
} }
#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */ #endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */
#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \ #if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \
!defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG) !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)
/* ZSTD_getLongOffsetsShare() : /* ZSTD_getLongOffsetsShare() :
@@ -2048,7 +2032,6 @@ ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
} }
} }
void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize) void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)
{ {
if (dst != dctx->previousDstEnd && dstSize > 0) { /* not contiguous */ if (dst != dctx->previousDstEnd && dstSize > 0) { /* not contiguous */
@@ -2059,7 +2042,6 @@ void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)
} }
} }
size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
void* dst, size_t dstCapacity, void* dst, size_t dstCapacity,
const void* src, size_t srcSize) const void* src, size_t srcSize)

4
lib/zstd/decompress/zstd_decompress_block.h
View File

@@ -8,7 +8,6 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
#ifndef ZSTD_DEC_BLOCK_H #ifndef ZSTD_DEC_BLOCK_H
#define ZSTD_DEC_BLOCK_H #define ZSTD_DEC_BLOCK_H
@@ -20,7 +19,6 @@
#include "../common/zstd_internal.h" /* blockProperties_t, and some public functions */ #include "../common/zstd_internal.h" /* blockProperties_t, and some public functions */
#include "zstd_decompress_internal.h" /* ZSTD_seqSymbol */ #include "zstd_decompress_internal.h" /* ZSTD_seqSymbol */
/* === Prototypes === */ /* === Prototypes === */
/* note: prototypes already published within `zstd.h` : /* note: prototypes already published within `zstd.h` :
@@ -32,7 +30,6 @@
* ZSTD_decodeSeqHeaders() * ZSTD_decodeSeqHeaders()
*/ */
/* Streaming state is used to inform allocation of the literal buffer */ /* Streaming state is used to inform allocation of the literal buffer */
typedef enum { typedef enum {
not_streaming = 0, not_streaming = 0,
@@ -64,5 +61,4 @@ void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
unsigned tableLog, void* wksp, size_t wkspSize, unsigned tableLog, void* wksp, size_t wkspSize,
int bmi2); int bmi2);
#endif /* ZSTD_DEC_BLOCK_H */ #endif /* ZSTD_DEC_BLOCK_H */

6
lib/zstd/decompress/zstd_decompress_internal.h
View File

@@ -8,22 +8,18 @@
* You may select, at your option, one of the above-listed licenses. * You may select, at your option, one of the above-listed licenses.
*/ */
/* zstd_decompress_internal: /* zstd_decompress_internal:
* objects and definitions shared within lib/decompress modules */ * objects and definitions shared within lib/decompress modules */
#ifndef ZSTD_DECOMPRESS_INTERNAL_H #ifndef ZSTD_DECOMPRESS_INTERNAL_H
#define ZSTD_DECOMPRESS_INTERNAL_H #define ZSTD_DECOMPRESS_INTERNAL_H
/*-******************************************************* /*-*******************************************************
* Dependencies * Dependencies
*********************************************************/ *********************************************************/
#include "../common/mem.h" /* BYTE, U16, U32 */ #include "../common/mem.h" /* BYTE, U16, U32 */
#include "../common/zstd_internal.h" /* constants : MaxLL, MaxML, MaxOff, LLFSELog, etc. */ #include "../common/zstd_internal.h" /* constants : MaxLL, MaxML, MaxOff, LLFSELog, etc. */
/*-******************************************************* /*-*******************************************************
* Constants * Constants
*********************************************************/ *********************************************************/
@@ -55,7 +51,6 @@ static UNUSED_ATTR const U32 ML_base[MaxML+1] = {
67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803, 67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,
0x1003, 0x2003, 0x4003, 0x8003, 0x10003 }; 0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };
/*-******************************************************* /*-*******************************************************
* Decompression types * Decompression types
*********************************************************/ *********************************************************/
@@ -224,5 +219,4 @@ size_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,
* This function cannot fail. */ * This function cannot fail. */
void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize); void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize);
#endif /* ZSTD_DECOMPRESS_INTERNAL_H */ #endif /* ZSTD_DECOMPRESS_INTERNAL_H */