lz4hc : minor editions for clarity

updated NEWS, in preparation for v1.8.2

Merge pull request #518 from felixhandte/fix-517-dict-size-truncation

Limit Dictionary Size During LZ4F Decompression

Merge pull request #516 from felixhandte/merge-dest-size

Merge _destSize Compress Variant into LZ4_compress_generic()

Merge _destSize Compress Variant into LZ4_compress_generic()

Add _destSize() to Fullbench

Limit Dictionary Size During LZ4F Decompression

Fixes lz4/lz4#517.

minor edit of block format

clarifying parsing restrictions near end of block.

Merge pull request #514 from svpv/clarifyBlockFormat

lz4_Block_format.md: clarify on short inputs and restrictions

Merge pull request #513 from felixhandte/integrate-static-frame-functions

Integrate Contents of `lz4frame_static.h` into `lz4frame.h`

lz4_Block_format.md: clarify on short inputs and restrictions

It occurred to me that the formula "The last 5 bytes are always
literals", on the list of "assumptions made by the decoder", is
remarkably ambiguous.  Suppose the decoder is presented with 5 bytes.
Are they literals?  It may seem that the decoder degenerates
to memcpy on short inputs.  But of course the answer is no,
so the formula needs some clarification.

Parsing restrictions should be explained as well, otherwise they look
like arbitrary numbers.  The 5-byte restriction has been mentioned
recently in connection with the shortcut in LZ4_decompress_generic,
so I add that.  The second restriction is left to be explained
by the author.

I also took the liberty to explain that empty inputs "are either
unrepresentable or can be represented with a null byte".  This wording
may actually have some merit: it leaves for the implementation,
as opposed to the spec, to decide whether the encoder can compress
empty inputs, and whether the decoder can produce an empty output
(which the implementation should further clarify).

Multiply-Include Header to Check Guard Macro Correctness

Change Over Includes in the Project

Integrate lz4frame_static.h Declarations into lz4frame.h

Merge pull request #512 from lz4/HC_dict

In-place unmutable dictionaries for LZ4HC

Merge pull request #511 from lz4/decFast

Fixed performance issue with LZ4_decompress_fast()

Merge pull request #488 from felixhandte/hc-dict-ctx

Use Dictionary In-Place in HC Mode

Remove Debug Log Statements

Remove the Framebench Tool

Revert Stream Size Const to Correct Value

Merge pull request #504 from baruchsiach/static-only-support

lib: allow to disable shared libraries

re-ordered parenthesis

to avoid mixing && and &
as suggested by @terrelln

Merge pull request #507 from lz4/clangPerf

fixed lz4_fast clang performance

fixed minor declaration issue with clang on msys

disable shortcut for LZ4_decompress_fast()

improving speed

fullbench compiled without assert()

to better reflect release speed

Merge pull request #510 from terrelln/bug-fix

Fix input size validation edge cases

Fix compilation error and assert.

Fix input size validation edge cases

The bug is a read up to 2 bytes past the end of the buffer.
There are three cases for this bug, one for each test case added.

* An empty input causes `token = *ip++` to read one byte too far.
* A one byte input with `(token >> ML_BITS) == RUN_MASK` causes
  one extra byte to be read without validation. This could be
  combined with the first bug to cause 2 extra bytes to be read.
* The case pointed out in issue #508, where `ip == iend` at the
  beginning of the loop after taking the shortcut.

Benchmarks show no regressions on clang or gcc-7 on both my mac
and devserver.

Fixes #508.

Merge pull request #509 from svpv/clarifyFastRisks

lz4.h: clarify the risks of using LZ4_decompress_fast()

lz4.h: clarify the risks of using LZ4_decompress_fast()

The notes about "security guarantee" and "malicious inputs" seemed
a bit non-technical to me, so I took the liberty to tone them down
and instead describe the actual risks in technical terms.  Namely,
the function never writes past the end of the output buffer, so
a direct hostile takeover (resulting in arbitrary code execution
soon after the return from the function) is not possible.  However,
the application can crash because of reads from unmapped pages.

I also took the liberty to describe what I believe is the only sensible
usage scenario for the function: "This function is only usable if the
originalSize of uncompressed data is known in advance," etc.

fixed incorrect comment

fixed clang performance in lz4_fast

The simple change from
`matchIndex+MAX_DISTANCE < current`
towards
`current - matchIndex > MAX_DISTANCE`

is enough to generate a 10% performance drop under clang.
Quite massive.
(I missed as my eyes were concentrated on gcc performance at that time).

The second version is more robust, because it also survives a situation where
`matchIndex > current`
due to overflows.

The first version requires matchIndex to not overflow.
Hence were added `assert()` conditions.

The only case where this can happen is with dictCtx compression,
in the case where the dictionary context is not initialized before loading the dictionary.
So it's enough to always initialize the context while loading the dictionary.

Change vLimit Calculation

Remove Redundant Static Assert

Simpler loadDict() Reset

Tolerate Base Pointer Underflow

Don't Segfault on Malloc Failure

Sign-Extend -1 to Pointer Width

Fix Constant Value

Handle Index Underflows Safely

Consts and Asserts and Other Minor Nits

Add Some Simple Fuzzer Tests

Add Comments on New Public APIs

Add API for Attaching Dictionaries

Also Reset the Chain Table

Remove inputBuffer from Context, Work Around its Absence

Remove Commented Out Support for Match Continuation over Segment Boundary

Fix Signedness of Comparison

Don't Clear the Dictionary Context Until No Longer Useful

Copy DictCtx into Working Context on Inputs Larger than 4 KB

Force Inline on HashChain

Split DictCtx-using Code Into Separate Inlining Chain

Use Fast Reset in LZ4F Again

Use Fast Reset API in LZ4F

Add Fast Reset Paths

Remove Match Upper Bounds Check

Fix Some Cast/Conversion Warnings

Fix Offset Math

Reset Stream in LZ4_compress_HC

Don't Bother Clearing Chain Table for Working Contexts

Push Previous Compression Offsets into the Past

Shift Dict Limit Checks out of the Loop

Clear Tables on Dict Load

Only Perform Dict Lookup if Attempts Remain

Avoid Resetting Chain Table

Avoid Resetting Hash Table

Perform Lookups into the Dictionary Context

Call LZ4F_applyCDict Even on NULL CDict

Set dictCtx Rather than memcpy'ing Ctx

Fully Bounds Check Hash Table Reads

Add a Dictionary Context Pointer to the HC Context

Add Debug Log Statements to HC

Fix Framebench Output Buffer Sizing

Fix Cast

Print Failure Message in Framebench

Switch to Unaligned Samples to Compress Different Blobs Each Time

Fix Framebench Statistics

Add Run Name to Frame Bench Output

Auto-Calculate Appropriate Repetition Count

Print More Detailed Results Inside bench(), Add Compression Levels

Check Compressed Buffer is Correct in Frame Bench

Add HC Calls to Framebench

Restore Framebench Tool

This reverts commit 70f14823a46719e81e808d9ed9df90f478bcfd3f.

Merge pull request #505 from lz4/dev

update to `dev`

Merge pull request #503 from lz4/l120

minor length reduction of several large lines

Merge pull request #502 from lhacc1/dev

Wrap likely/unlikely macroses with #ifndef

modified indentation for consistency

lib: allow to disable shared libraries

Just like BUILD_STATIC=no disables static libraries, BUILD_SHARED=no
disabled shared libraries. This is useful to support toolchains that do
not support shared libraries.

minor length reduction of several large lines

Merge pull request #497 from lz4/lowAddr

Compatibility with low memory addresses

Wrap likely/unlikely macroses with #ifndef

It prevent redefine error when project using lz4 has its own likely/unlikely
macroses.

fixed LZ4_compress_fast_extState_fastReset() in 32-bit mode

fix dictDelta setting error

wrong test

fix matchIndex overflow

can happen with dictCtx

Merge branch 'dev' into lowAddr

Merge pull request #501 from felixhandte/fix-dict-load-offset

Always Bump Offset by 64 KB in LZ4_loadDict()

Always Bump Offset by 64 KB in LZ4_loadDict()

This actually ensures the guarantee referred to in the comment in
LZ4_compress_fast_continue().

fixed dictCtx compression

edited a few traces for debugging