Set version to 0.90.0

* Replace Ubuntu scons dependency with cmake
* Remove dependency installation support for Ubuntu 12.04 Precise Pangolin.
  It is EOL'd as of 2017-04-28. http://releases.ubuntu.com/12.04/

.travis.yml

@@ -38,14 +38,14 @@ matrix:
   include:
     # Default BUILD is "scons".
 
-    - compiler: gcc
-      env: GCC_VER=5 BUILD=cmake TARGET=debug.nounity PATH=$PWD/cmake/bin:$PATH
+    # - compiler: gcc
+    #   env: GCC_VER=5 TARGET=debug.nounity
 
     - compiler: gcc
-      env: GCC_VER=5 TARGET=coverage
+      env: GCC_VER=5 BUILD=cmake TARGET=coverage PATH=$PWD/cmake/bin:$PATH
 
     - compiler: clang
-      env: GCC_VER=5 TARGET=debug CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PATH
+      env: GCC_VER=5 BUILD=cmake TARGET=debug CLANG_VER=3.8 PATH=$PWD/llvm-$LLVM_VERSION/bin:$PWD/cmake/bin:$PATH
       cache:
         directories:
           - $GDB_ROOT

Builds/CMake/CMakeFuncs.cmake

@@ -337,7 +337,13 @@ macro(use_boost)
       set(BOOST_ROOT $ENV{CLANG_BOOST_ROOT})
     endif()
 
-    set(Boost_USE_STATIC_LIBS on)
+    # boost dynamic libraries don't trivially support @rpath
+    # linking right now (cmake's default), so just force
+    # static linking for macos, or if requested on linux
+    # by flag
+    if (static OR APPLE)
+      set(Boost_USE_STATIC_LIBS on)
+    endif()
     set(Boost_USE_MULTITHREADED on)
     set(Boost_USE_STATIC_RUNTIME off)
     if(MSVC)
@@ -351,7 +357,21 @@ macro(use_boost)
       if(NOT Boost_FOUND)
         message(WARNING "Boost directory found, but not all components. May not be able to build.")
       endif()
-      include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
+
+      if(MSVC14)
+        # VS2017 with boost <= 1.66.0 requires a flag to suppress warnings
+        if(NOT Boost_VERSION VERSION_GREATER 106600)
+          add_definitions(-DBOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE)
+        endif()
+      endif()
+
+      if (is_xcode)
+          include_directories(BEFORE ${Boost_INCLUDE_DIRS})
+          append_flags(CMAKE_CXX_FLAGS --system-header-prefix="boost/")
+      else()
+          include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
+      endif()
+
       link_directories(${Boost_LIBRARY_DIRS})
     else()
       message(FATAL_ERROR "Boost not found")
@@ -377,9 +397,13 @@ macro(use_openssl openssl_min)
   endif()
 
   if (WIN32)
-    if (DEFINED ENV{OPENSSL_ROOT})
-      include_directories($ENV{OPENSSL_ROOT}/include)
-      link_directories($ENV{OPENSSL_ROOT}/lib)
+    if ((NOT DEFINED OPENSSL_ROOT) AND (DEFINED ENV{OPENSSL_ROOT}))
+      set(OPENSSL_ROOT $ENV{OPENSSL_ROOT})
+    endif()
+    file(TO_CMAKE_PATH "${OPENSSL_ROOT}" OPENSSL_ROOT)
+    if (DEFINED OPENSSL_ROOT)
+      include_directories(${OPENSSL_ROOT}/include)
+      link_directories(${OPENSSL_ROOT}/lib)
     endif()
   else()
     if (static)
@@ -524,11 +548,15 @@ macro(setup_build_boilerplate)
 
     string(TOLOWER ${san} ci_san)
     if (${ci_san} STREQUAL address)
-      set(SANITIZER_LIBRARIES asan)
+      if (is_gcc)
+        set(SANITIZER_LIBRARIES asan)
+      endif()
       add_definitions(-DSANITIZER=ASAN)
     endif()
     if (${ci_san} STREQUAL thread)
-      set(SANITIZER_LIBRARIES tsan)
+      if (is_gcc)
+        set(SANITIZER_LIBRARIES tsan)
+      endif()
       add_definitions(-DSANITIZER=TSAN)
     endif()
   endif()
@@ -566,7 +594,7 @@ macro(setup_build_boilerplate)
     #  An alternative to disabling would be to figure out all the settings
     #  required to make gold play nicely with jemalloc.
     if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
-        append_flags(CMAKE_EXE_LINKER_FLAGS -fuse-ld=gold)
+        append_flags(CMAKE_EXE_LINKER_FLAGS -fuse-ld=gold -Wl,--no-as-needed)
     endif ()
     unset(LD_VERSION)
   endif()
@@ -606,7 +634,7 @@ macro(setup_build_boilerplate)
 
   if (NOT WIN32)
     add_definitions(-D_FILE_OFFSET_BITS=64)
-    append_flags(CMAKE_CXX_FLAGS -frtti -std=c++14 -Wno-invalid-offsetof
+    append_flags(CMAKE_CXX_FLAGS -frtti -std=c++14 -Wno-invalid-offsetof -Wdeprecated
       -DBOOST_COROUTINE_NO_DEPRECATION_WARNING -DBOOST_COROUTINES_NO_DEPRECATION_WARNING)
     add_compile_options(-Wall -Wno-sign-compare -Wno-char-subscripts -Wno-format
       -Wno-unused-local-typedefs -g)
@@ -634,7 +662,7 @@ macro(setup_build_boilerplate)
     if (APPLE)
       add_definitions(-DBEAST_COMPILE_OBJECTIVE_CPP=1)
       add_compile_options(
-        -Wno-deprecated -Wno-deprecated-declarations -Wno-unused-function)
+        -Wno-deprecated-declarations -Wno-unused-function)
     endif()
 
     if (is_gcc)

Builds/Test.py

@@ -154,6 +154,13 @@ parser.add_argument(
     help='Add a prefix for unit tests',
 )
 
+parser.add_argument(
+    '--testjobs',
+    default='0',
+    type=int,
+    help='Run tests in parallel'
+)
+
 parser.add_argument(
     '--clean', '-c',
     action='store_true',
@@ -257,17 +264,20 @@ def shell(cmd, args=(), silent=False):
     count = 0
     # readline returns '' at EOF
     for line in iter(process.stdout.readline, ''):
-        decoded = decodeString(line)
-        lines.append(decoded)
-        if verbose:
-            print(decoded, end='')
-        elif not silent:
-            count += 1
-            if count >= 80:
-                print()
-                count = 0
-            else:
-                print('.', end='')
+        if process.poll() is None:
+            decoded = decodeString(line)
+            lines.append(decoded)
+            if verbose:
+                print(decoded, end='')
+            elif not silent:
+                count += 1
+                if count >= 80:
+                    print()
+                    count = 0
+                else:
+                    print('.', end='')
+        else:
+            break
 
     if not verbose and count:
         print()
@@ -294,7 +304,9 @@ def run_tests(args):
                 testflag += ('=' + ARGS.test)
             if ARGS.quiet:
                 quiet = '-q'
-            resultcode, lines = shell(executable, (testflag, quiet,))
+            if ARGS.testjobs:
+                testjobs = ('--unittest-jobs=' + str(ARGS.testjobs))
+            resultcode, lines = shell(executable, (testflag, quiet, testjobs,))
 
             if resultcode:
                 if not ARGS.verbose:
@@ -377,11 +389,14 @@ def run_cmake_tests(directory, target, config):
     print('Unit tests for', executable)
     testflag = '--unittest'
     quiet = ''
+    testjobs = ''
     if ARGS.test:
         testflag += ('=' + ARGS.test)
     if ARGS.quiet:
         quiet = '-q'
-    resultcode, lines = shell(executable, (testflag, quiet,))
+    if ARGS.testjobs:
+        testjobs = ('--unittest-jobs=' + str(ARGS.testjobs))
+    resultcode, lines = shell(executable, (testflag, quiet, testjobs,))
 
     if resultcode:
         if not ARGS.verbose:

Builds/Ubuntu/install_rippled_depends_ubuntu.sh

@@ -19,18 +19,6 @@ if [ -z "${ubuntu_release}" ]; then
     exit 1
 fi
 
-if [ ${ubuntu_release} == "12.04" ]; then
-    apt-get install python-software-properties
-    add-apt-repository ppa:afrank/boost
-    add-apt-repository ppa:ubuntu-toolchain-r/test
-    apt-get update
-    apt-get -y upgrade
-    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost1.57-all-dev g++-5 g++-4.9
-    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
-    update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
-    exit 0
-fi
-
 if [ ${ubuntu_release} == "14.04" ] || [ ${ubuntu_release} == "15.04" ]; then
     apt-get install python-software-properties
     echo "deb [arch=amd64] https://mirrors.ripple.com/ubuntu/ trusty stable contrib" | sudo tee /etc/apt/sources.list.d/ripple.list
@@ -38,7 +26,7 @@ if [ ${ubuntu_release} == "14.04" ] || [ ${ubuntu_release} == "15.04" ]; then
     add-apt-repository ppa:ubuntu-toolchain-r/test
     apt-get update
     apt-get -y upgrade
-    apt-get -y install curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost-all-dev g++-5 g++-4.9
+    apt-get -y install curl git cmake ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties boost-all-dev g++-5 g++-4.9
     update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 99 --slave /usr/bin/g++ g++ /usr/bin/g++-5
     update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.9 99 --slave /usr/bin/g++ g++ /usr/bin/g++-4.9
     exit 0
@@ -51,7 +39,7 @@ function version_check() { test "$(printf '%s\n' "$@" | sort -V | tail -n 1)" ==
 if version_check ${ubuntu_release} 15.10; then
     apt-get update
     apt-get -y upgrade
-    apt-get -y install python-software-properties curl git scons ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties libboost-all-dev
+    apt-get -y install python-software-properties curl git cmake ctags pkg-config protobuf-compiler libprotobuf-dev libssl-dev python-software-properties libboost-all-dev
     exit 0
 fi
 

Builds/VisualStudio2017/CMakeSettings-example.json

@@ -0,0 +1,45 @@
+{
+  // See https://go.microsoft.com//fwlink//?linkid=834763 for more information about this file.
+  "configurations": [
+    {
+      "name": "x64-Debug",
+      "generator": "Visual Studio 15 2017 Win64",
+      "configurationType": "Debug",
+      "inheritEnvironments": [ "msvc_x64_x64" ],
+      "buildRoot": "${thisFileDir}\\build\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "-v:minimal",
+      "ctestCommandArgs": "",
+      "variables": [
+        {
+          "name": "BOOST_ROOT",
+          "value": "C:\\lib\\boost"
+        },
+        {
+          "name": "OPENSSL_ROOT",
+          "value": "C:\\lib\\OpenSSL-Win64"
+        }
+      ]
+    },
+    {
+      "name": "x64-Release",
+      "generator": "Visual Studio 15 2017 Win64",
+      "configurationType": "Release",
+      "inheritEnvironments": [ "msvc_x64_x64" ],
+      "buildRoot": "${thisFileDir}\\build\\${name}",
+      "cmakeCommandArgs": "",
+      "buildCommandArgs": "-v:minimal",
+      "ctestCommandArgs": "",
+      "variables": [
+        {
+          "name": "BOOST_ROOT",
+          "value": "C:\\lib\\boost"
+        },
+        {
+          "name": "OPENSSL_ROOT",
+          "value": "C:\\lib\\OpenSSL-Win64"
+        }
+      ]
+    }
+  ]
+}

Builds/VisualStudio2017/README.md

@@ -0,0 +1,263 @@
+# Visual Studio 2017 Build Instructions
+
+## Important
+
+We do not recommend Windows for rippled production use at this time. Currently,
+the Ubuntu platform has received the highest level of quality assurance,
+testing, and support. Additionally, 32-bit Windows versions are not supported.
+
+## Prerequisites
+
+To clone the source code repository, create branches for inspection or
+modification, build rippled under Visual Studio, and run the unit tests you will
+need these software components
+
+| Component | Minimum Recommended Version |
+|-----------|-----------------------|
+| [Visual Studio 2017](README.md#install-visual-studio-2017)| 15.5.4 |
+| [Git for Windows](README.md#install-git-for-windows)| 2.16.1|
+| [Google Protocol Buffers Compiler](README.md#install-google-protocol-buffers-compiler) | 2.5.1|
+| [OpenSSL Library](README.md#install-openssl) | 1.0.2n |
+| [Boost library](README.md#build-boost) | 1.66.0 |
+| [CMake for Windows](README.md#optional-install-cmake-for-windows)* | 3.10.2 |
+
+\* Only needed if not using the integrated CMake in VS 2017 and prefer generating dedicated project/solution files.
+
+## Install Software
+
+### Install Visual Studio 2017
+
+If not already installed on your system, download your choice of installer from
+the [Visual Studio 2017
+Download](https://www.visualstudio.com/downloads/download-visual-studio-vs)
+page, run the installer, and follow the directions. **You may need to choose the
+`Desktop development with C++` workload to install all necessary C++ features.**
+
+Any version of Visual Studio 2017 may be used to build rippled. The **Visual
+Studio 2017 Community** edition is available free of charge (see [the product
+page](https://www.visualstudio.com/products/visual-studio-community-vs) for
+licensing details), while paid editions may be used for an initial free-trial
+period.
+
+### Install Git for Windows
+
+Git is a distributed revision control system. The Windows version also provides
+the bash shell and many Windows versions of Unix commands. While there are other
+varieties of Git (such as TortoiseGit, which has a native Windows interface and
+integrates with the Explorer shell), we recommend installing [Git for
+Windows](https://git-scm.com/) since it provides a Unix-like command line
+environment useful for running shell scripts. Use of the bash shell under
+Windows is mandatory for running the unit tests.
+
+### Install Google Protocol Buffers Compiler
+
+Building rippled requires **protoc.exe** version 2. Version 3 is not currently
+supported.. At your option you may build it yourself from the sources in the
+[Google Protocol Buffers](https://github.com/google/protobuf) repository, or you
+may download a
+[protoc.exe](https://ripple.github.io/Downloads/protoc/2.5.1/protoc.exe)
+([alternate
+link](https://github.com/ripple/Downloads/raw/gh-pages/protoc/2.5.1/protoc.exe))
+precompiled Windows executable from the [Ripple
+Organization](https://github.com/ripple).
+
+Either way, once you have the required version of **protoc.exe**, copy it into a
+standard location that is in your command line `%PATH%`.
+
+* **NOTE:** If you use an older version of the compiler, the build will fail
+  with errors related to a mismatch of the version of protocol buffer headers
+  versus the compiler. Likewise, if you use version 3 or newer, the build will
+  fail.
+
+### Install OpenSSL
+
+[Download OpenSSL.](http://slproweb.com/products/Win32OpenSSL.html) There will
+four `Win64` bit variants available, you want the non-light `v1.0` line. As of
+this writing, you **should** select
+
+* Win64 OpenSSL v1.0.2n. 
+
+and should **not** select
+
+* Win64 OpenSSL v1.0.2n light
+* Win64 OpenSSL v1.1.0g
+* Win64 OpenSSL v1.1.0g light
+
+Run the installer, and choose an appropriate location for your OpenSSL
+installation. In this guide we use `C:\lib\OpenSSL-Win64` as the destination
+location.
+
+You may be informed on running the installer that "Visual C++ 2008
+Redistributables" must first be installed first. If so, download it from the
+[same page](http://slproweb.com/products/Win32OpenSSL.html), again making sure
+to get the correct 32-/64-bit variant.
+
+* NOTE: Since rippled links statically to OpenSSL, it does not matter where the
+  OpenSSL .DLL files are placed, or what version they are. rippled does not use
+  or require any external .DLL files to run other than the standard operating
+  system ones.
+
+### Build Boost
+
+After [downloading boost](http://www.boost.org/users/download/) and unpacking it
+to `c:\lib`. As of this writing, the most recent version of boost is 1.66.0,
+which will unpack into a directory named `boost_1_66_0`. We recommended either
+renaming this directory to `boost`, or creating a junction link `mklink /J boost
+boost_1_66_0`, so that you can more easily switch between versions.
+
+Next, open **Developer Command Prompt** and type the following commands
+
+```powershell
+cd C:\lib\boost
+bootstrap
+```
+
+The rippled application is linked statically to the standard runtimes and
+external dependencies on Windows, to ensure that the behavior of the executable
+is not affected by changes in outside files. Therefore, it is necessary to build
+the required boost static libraries using this command:
+
+```powershell
+bjam -j<Num Parallel> --toolset=msvc-14.1 address-model=64 architecture=x86 link=static threading=multi runtime-link=shared,static stage
+```
+
+where you should replace `<Num Parallel>` with the number of parallel
+invocations to use build, e.g. `bjam -j4 ...` would use up to 4 concurrent build
+shell commands for the build.
+
+Building the boost libraries may take considerable time. When the build process
+is completed, take note of both the reported compiler include paths and linker
+library paths as they will be required later.
+
+### (Optional) Install CMake for Windows
+
+[CMake](http://cmake.org) is a cross platform build system generator. Visual
+Studio 2017 includes an integrated version of CMake that avoids having to
+manually run CMake, but it is undergoing continuous improvement. Users that
+prefer to use standard Visual Studio project and solution files need to install
+a dedicated version of Cmake to generate them.  The latest version can be found
+at the [CMake download site](https://cmake.org/download/). It is recommended you
+select the install option to add CMake to your path.
+
+As of this writing, the latest version of CMake for windows is 3.10.2.
+
+## Clone the rippled repository
+
+If you are familiar with cloning github repositories, just follow your normal
+process and clone `git@github.com:ripple/rippled.git`. Otherwise follow this
+section for instructions.
+
+1. If you don't have a github account, sign up for one at
+   [github.com](https://github.com/).
+2. Make sure you have Github ssh keys. For help see
+   [generating-ssh-keys](https://help.github.com/articles/generating-ssh-keys).
+
+Open the "Git Bash" shell that was installed with "Git for Windows" in the step
+above. Navigate to the directory where you want to clone rippled (git bash uses
+`/c` for windows's `C:` and forward slash where windows uses backslash, so
+`C:\Users\joe\projs` would be `/c/Users/joe/projs` in git bash). Now clone the
+repository and optionally switch to the *master* branch. Type the following at
+the bash prompt:
+
+```powershell
+git clone git@github.com:ripple/rippled.git
+cd rippled
+```
+If you receive an error about not having the "correct access rights" make sure
+you have Github ssh keys, as described above.
+
+For a stable release, choose the `master` branch or one of the tagged releases
+listed on [rippled's GitHub page](https://github.com/ripple/rippled/releases). 
+
+```
+git checkout master
+```
+
+To test the latest release candidate, choose the `release` branch.
+
+```
+git checkout release
+```
+
+If you are doing development work and want the latest set of untested features,
+you can consider using the `develop` branch instead.
+
+```
+git checkout develop
+```
+
+# Build using Visual Studio integrated CMake
+
+In Visual Studio 2017, Microsoft added [integrated IDE support for
+cmake](https://blogs.msdn.microsoft.com/vcblog/2016/10/05/cmake-support-in-visual-studio/).
+To begin, simply:
+
+1. Launch Visual Studio and choose **File | Open | Folder**, navigating to the
+   cloned rippled folder.
+2. Right-click on `CMakeLists.txt` in the **Solution Explorer - Folder View** to
+   generate a `CMakeSettings.json` file. A sample settings file is provided
+   [here](/Builds/VisualStudio2017/CMakeSettings-example.json). Customize the 
+   settings for `BOOST_ROOT`, `OPENSSL_ROOT` to match the install paths if they
+   differ from those in the file.
+4. Select either the `x64-Release` or `x64-Debug` configuration from the
+   **Project Setings** drop-down. This should invoke the built-in CMake project
+   generator. If not, you can right-click on the `CMakeLists.txt` file and
+   choose **Cache | Generate Cache**.
+5. Select either the `rippled.exe` (unity) or `rippled_classic.exe` (non-unity)
+   option in the **Select Startup Item** drop-down. This will be the target
+   built when you press F7. Alternatively, you can choose a target to build from
+   the top-level **CMake | Build** menu. Note that at this time, there are other
+   targets listed that come from third party visual studio files embedded in the
+   rippled repo, e.g. `datagen.vcxproj`. Please ignore them.
+
+For details on configuring debugging sessions or further customization of CMake,
+please refer to the [CMake tools for VS
+documentation](https://docs.microsoft.com/en-us/cpp/ide/cmake-tools-for-visual-cpp).
+
+If using the provided `CMakeSettings.json` file, the executable will be in
+```
+.\build\x64-Release\Release\rippled(_classic).exe
+```
+or
+```
+.\build\x64-Debug\Debug\rippled(_classic).exe
+```
+where these paths are relative to your cloned git repository.
+
+# Build using stand-alone CMake
+
+This requires having installed [CMake for
+Windows](README.md#optional-install-cmake-for-windows). We do not recommend
+mixing this method with the integrated CMake method for the same repository
+clone. Assuming you included the cmake executable folder in your path,
+execute the following commands within your `rippled` cloned repository:
+
+```
+mkdir build\cmake
+cd build\cmake
+cmake ..\.. -G"Visual Studio 15 2017 Win64" -DBOOST_ROOT="C:\lib\boost_1_66_0" -DOPENSSL_ROOT="C:\lib\OpenSSL-Win64"
+```
+Now launch Visual Studio 2017 and select **File | Open | Project/Solution**.
+Navigate to the `build\cmake` folder created above and select the `rippled.sln`
+file. You can then choose whether to build the `Debug` or `Release` solution
+configuration. Within the **Solution Explorer**, selected either the `rippled`
+(unity build) project or the `rippled_classic` (non-unity) project, and
+right-click to build.
+
+The executable will be in 
+```
+.\build\cmake\Release\rippled(_classic).exe
+```
+ or
+````
+.\build\cmake\Debug\rippled(_classic).exe
+````
+where these paths are relative to your cloned git repository.
+
+# Unit Test (Recommended)
+
+`rippled` builds a set of unit tests into the server executable. To run these
+unit tests after building, pass the `--unittest` option to the compiled
+`rippled` executable. The executable will exit with summary info after running
+the unit tests.
+

Builds/XCode/README.md

@@ -1,183 +0,0 @@
-# macos Build Instructions
-
-## Important
-
-We don't recommend macos for rippled production use at this time. Currently, the
-Ubuntu platform has received the highest level of quality assurance and
-testing. That said, macos is suitable for many development/test tasks.
-
-## Prerequisites
-
-You'll need macos 10.8 or later
-
-To clone the source code repository, create branches for inspection or
-modification, build rippled using clang, and run the system tests you will need
-these software components:
-
-* [XCode](https://developer.apple.com/xcode/)
-* [Homebrew](http://brew.sh/)
-* [Git](http://git-scm.com/)
-* [CMake](http://cmake.org/)
-
-## Install Software
-
-### Install XCode
-
-If not already installed on your system, download and install XCode using the
-appstore or by using [this link](https://developer.apple.com/xcode/).
-
-For more info, see "Step 1: Download and Install the Command Line Tools"
-[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
-
-The command line tools can be installed through the terminal with the command:
-
-```
-xcode-select --install
-```
-
-### Install Homebrew
-
-> "[Homebrew](http://brew.sh/) installs the stuff you need that Apple didn’t."
-
-Open a terminal and type:
-
-```
-ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
-```
-
-For more info, see "Step 3: Install Homebrew"
-[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
-
-### Install Git
-
-```
-brew update brew install git
-```
-
-For more info, see "Step 4: Install Git"
-[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
-
-**NOTE**: To gain full featured access to the
-[git-subtree](http://blogs.atlassian.com/2013/05/alternatives-to-git-submodule-git-subtree/)
-functionality used in the rippled repository, we suggest Git version 1.8.3.2 or
-later.
-
-### Install Scons
-
-Requires version 3.6.0 or later
-
-```
-brew install cmake
-```
-
-`brew` will generally install the latest stable version of any package, which
-should satisfy the cmake minimum version requirement for rippled.
-
-### Install Package Config
-
-```
-brew install pkg-config
-```
-
-## Install/Build/Configure Dependencies
-
-### Build Google Protocol Buffers Compiler
-
-Building rippled on osx requires `protoc` version 2.5.x or 2.6.x (later versions
-do not work with rippled at this time).
-
-Download [this](https://github.com/google/protobuf/releases/download/v2.6.1/protobuf-2.6.1.tar.bz2)
-
-We want to compile protocol buffers with clang/libc++:
-
-```
-tar xfvj protobuf-2.6.1.tar.bz2
-cd protobuf-2.6.1
-./configure CC=clang CXX=clang++ CXXFLAGS='-std=c++11 -stdlib=libc++ -O3 -g' LDFLAGS='-stdlib=libc++' LIBS="-lc++ -lc++abi"
-make -j 4
-sudo make install
-```
-
-If you have installed `protobuf` via brew - either directly or indirectly as a
-dependency of some other package - this is likely to conflict with our specific
-version requirements. The simplest way to avoid conflicts is to uninstall it.
-`brew ls --versions protobuf` will list any versions of protobuf
-you currently have installed.
-
-### Install OpenSSL
-
-```
-brew install openssl
-```
-
-### Build Boost
-
-We want to compile boost with clang/libc++
-
-Download [a release](https://sourceforge.net/projects/boost/files/boost/1.61.0/boost_1_61_0.tar.bz2)
-
-Extract it to a folder, making note of where, open a terminal, then:
-
-```
-./bootstrap.sh ./b2 toolset=clang threading=multi runtime-link=static link=static cxxflags="-stdlib=libc++" linkflags="-stdlib=libc++" address-model=64
-```
-
-Create an environment variable `BOOST_ROOT` in one of your `rc` files, pointing
-to the root of the extracted directory.
-
-### Clone the rippled repository
-
-From the terminal
-
-```
-git clone git@github.com:ripple/rippled.git
-cd rippled
-```
-
-Choose the master branch or one of the tagged releases listed on
-[GitHub](https://github.com/ripple/rippled/releases GitHub).
-
-```
-git checkout master
-```
-
-or to test the latest release candidate, choose the `release` branch.
-
-```
-git checkout release
-```
-
-### Configure Library Paths
-
-If you didn't persistently set the `BOOST_ROOT` environment variable to the
-root of the extracted directory above, then you should set it temporarily.
-
-For example, assuming your username were `Abigail` and you extracted Boost
-1.61.0 in `/Users/Abigail/Downloads/boost_1_61_0`, you would do for any
-shell in which you want to build:
-
-```
-export BOOST_ROOT=/Users/Abigail/Downloads/boost_1_61_0
-```
-
-## Build
-
-```
-mkdir xcode_build && cd xcode_build
-cmake -GXcode ..
-```
-
-There are a number of variables/options that our CMake files support and they
-can be added to the above command as needed (e.g. `-Dassert=ON` to enable
-asserts)
-
-After generation succeeds, the xcode project file can be opened and used to
-build and debug.
-
-## Unit Tests (Recommended)
-
-rippled builds a set of unit tests into the server executable. To run these unit
-tests after building, pass the `--unittest` option to the compiled `rippled`
-executable. The executable will exit after running the unit tests.
-
-

Builds/build_all.sh

@@ -4,5 +4,5 @@ num_procs=$(lscpu -p | grep -v '^#' | sort -u -t, -k 2,4 | wc -l) # number of ph
 
 path=$(cd $(dirname $0) && pwd)
 cd $(dirname $path)
-${path}/Test.py -a -c --test=TxQ -- -j${num_procs}
-${path}/Test.py -a -c -k --test=TxQ --cmake -- -j${num_procs}
+${path}/Test.py -a -c --testjobs=${num_procs} -- -j${num_procs}
+${path}/Test.py -a -c -k --cmake --testjobs=${num_procs} -- -j${num_procs}

Builds/macos/README.md

@@ -0,0 +1,206 @@
+# macos Build Instructions
+
+## Important
+
+We don't recommend macos for rippled production use at this time. Currently, the
+Ubuntu platform has received the highest level of quality assurance and
+testing. That said, macos is suitable for many development/test tasks.
+
+## Prerequisites
+
+You'll need macos 10.8 or later.
+
+To clone the source code repository, create branches for inspection or
+modification, build rippled using clang, and run the system tests you will need
+these software components:
+
+* [XCode](https://developer.apple.com/xcode/)
+* [Homebrew](http://brew.sh/)
+* [Boost](http://boost.org/)
+* other misc utilities and libraries installed via homebrew
+
+## Install Software
+
+### Install XCode
+
+If not already installed on your system, download and install XCode using the
+appstore or by using [this link](https://developer.apple.com/xcode/).
+
+For more info, see "Step 1: Download and Install the Command Line Tools"
+[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac)
+
+The command line tools can be installed through the terminal with the command:
+
+```
+xcode-select --install
+```
+
+### Install Homebrew
+
+> "[Homebrew](http://brew.sh/) installs the stuff you need that Apple didn’t."
+
+Open a terminal and type:
+
+```
+ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+```
+
+For more info, see "Step 2: Install Homebrew"
+[here](http://www.moncefbelyamani.com/how-to-install-xcode-homebrew-git-rvm-ruby-on-mac#step-2)
+
+### Install Dependencies Using Homebrew
+
+`brew` will generally install the latest stable version of any package, which
+should satisfy the the minimum version requirements for rippled.
+
+```
+brew update
+brew install git cmake pkg-config protobuf openssl ninja
+```
+
+### Build Boost
+
+We want to compile boost with clang/libc++
+
+Download [a release](https://dl.bintray.com/boostorg/release/1.66.0/source/boost_1_66_0.tar.bz2)
+
+Extract it to a folder, making note of where, open a terminal, then:
+
+```
+./bootstrap.sh
+./b2 cxxflags="-std=c++14"
+```
+
+Create an environment variable `BOOST_ROOT` in one of your `rc` files, pointing
+to the root of the extracted directory.
+
+### Dependencies for Building Source Documentation
+
+Source code documentation is not required for running/debugging rippled. That
+said, the documentation contains some helpful information about specific
+components of the application. For more information on how to install and run
+the necessary components, see [this document](../../docs/README.md)
+
+## Build
+
+### Clone the rippled repository
+
+From a shell:
+
+```
+git clone git@github.com:ripple/rippled.git
+cd rippled
+```
+
+For a stable release, choose the `master` branch or one of the tagged releases
+listed on [GitHub](https://github.com/ripple/rippled/releases GitHub). 
+
+```
+git checkout master
+```
+
+or to test the latest release candidate, choose the `release` branch.
+
+```
+git checkout release
+```
+
+If you are doing development work and want the latest set of untested
+features, you can consider using the `develop` branch instead.
+
+```
+git checkout develop
+```
+
+### Configure Library Paths
+
+If you didn't persistently set the `BOOST_ROOT` environment variable to the
+root of the extracted directory above, then you should set it temporarily.
+
+For example, assuming your username were `Abigail` and you extracted Boost
+1.66.0 in `/Users/Abigail/Downloads/boost_1_66_0`, you would do for any
+shell in which you want to build:
+
+```
+export BOOST_ROOT=/Users/Abigail/Downloads/boost_1_66_0
+```
+
+### Generate and Build
+
+For simple command line building we recommend using the *Unix Makefile* or
+*Ninja* generator with cmake. All builds should be done in a separate directory
+from the source tree root (a subdirectory is fine). For example, from the root
+of the ripple source tree:
+
+```
+mkdir my_build
+cd my_build
+```
+
+followed by:
+
+```
+cmake -G "Unix Makefiles" -Dtarget=clang.debug.unity ..
+```
+
+or
+
+```
+cmake -G "Ninja" -Dtarget=clang.debug.unity ..
+```
+
+The target variable can be adjusted as needed for `debug` vs. `release` and
+`unity` vs. `nounity` builds. `unity` builds are typically faster to compile
+but run the risk of ODR violations given that multiple compilation units are
+merged together at compile time. `nounity` builds will take longer to compile
+but align more closely with language standards. 
+
+Once you have generated the build system, you can run the build via cmake:
+
+```
+cmake --build . -- -j 4
+```
+
+the `-j` parameter in this example tells the build tool to compile several
+files in parallel. This value should be chosen roughly based on the number of
+cores you have available and/or want to use for building.
+
+When the build completes succesfully, you will have a `rippled` executable in
+the current directory, which can be used to connect to the network (when
+properly configured) or to run unit tests.
+
+If you prefer to have an XCode project to use for building, ask CMake to
+generate that instead:
+
+```
+cmake -GXcode ..
+```
+
+After generation succeeds, the xcode project file can be opened and used to
+build/debug. However, just as with other generators, cmake knows how to build
+using the xcode project as well:
+
+```
+cmake --build . -- -jobs 4
+```
+
+This will invoke the `xcodebuild` utility to compile the project. See `xcodebuild
+--help` for details about build options.
+
+#### Options During Configuration:
+
+There are a number of config variables that our CMake files support. These
+can be added to the cmake generation command as needed:
+
+* `-Dassert=ON` to enable asserts
+* `-Djemalloc=ON` to enable jemalloc support for heap checking
+* `-Dsan=thread` to enable the thread sanitizer with clang
+* `-Dsan=address` to enable the address sanitizer with clang
+
+## Unit Tests (Recommended)
+
+`rippled` builds a set of unit tests into the server executable. To run these unit
+tests after building, pass the `--unittest` option to the compiled `rippled`
+executable. The executable will exit with summary info after running the unit tests.
+
+

CMakeLists.txt

@@ -150,6 +150,7 @@ use_boost(
   filesystem
   program_options
   regex
+  serialization
   system
   thread)
 
@@ -322,7 +323,8 @@ foreach(curdir
         resource
         rpc
         server
-        shamap)
+        shamap
+        unit_test)
     file(GLOB_RECURSE cursrcs src/test/${curdir}/*.cpp)
     list(APPEND test_srcs "${cursrcs}")
 endforeach()

Jenkinsfile

@@ -0,0 +1,348 @@
+#!/usr/bin/env groovy
+
+import groovy.json.JsonOutput
+import java.text.*
+
+def all_status = [:]
+def commit_id = ''
+// this is not the actual token, but an ID/key into the jenkins
+// credential store which httpRequest can access.
+def github_cred = '6bd3f3b9-9a35-493e-8aef-975403c82d3e'
+//
+// root API url for our repo (default, overriden below)
+//
+String github_repo = 'https://api.github.com/repos/ripple/rippled'
+
+try {
+    stage ('Startup Checks') {
+        // here we check the commit author against collaborators
+        // we need a node to do this because readJSON requires
+        // a filesystem (although we just pass it text)
+        node {
+            checkout scm
+            commit_id = sh(
+                script: 'git rev-parse HEAD',
+                returnStdout: true)
+            commit_id = commit_id.trim()
+            echo "commit ID is ${commit_id}"
+            commit_log = sh (
+                 script: "git show --name-status ${commit_id}",
+                 returnStdout: true)
+            printGitInfo (commit_id, commit_log)
+            //
+            // NOTE this getUserRemoteConfigs call requires a one-time
+            // In-process Script Approval (configure jenkins). We need this
+            // to detect the remote repo to interact with via the github API.
+            //
+            def remote_url = scm.getUserRemoteConfigs()[0].getUrl()
+            if (remote_url) {
+                echo "GIT URL scm: $remote_url"
+                def fork = remote_url.tokenize('/')[2]
+                def repo = remote_url.tokenize('/')[3].split('\\.')[0]
+                echo "GIT FORK: $fork"
+                echo "GIT REPO: $repo"
+                github_repo = "https://api.github.com/repos/${fork}/${repo}"
+                echo "API URL REPO: $github_repo"
+            }
+
+            if (env.CHANGE_AUTHOR) {
+                //
+                // this means we have some sort of PR , so verify the author
+                //
+                echo "CHANGE AUTHOR ---> $CHANGE_AUTHOR"
+                echo "CHANGE TARGET ---> $CHANGE_TARGET"
+                echo "CHANGE ID ---> $CHANGE_ID"
+                //
+                // check the commit author against collaborators
+                // we need a node to do this because readJSON requires
+                // a filesystem (although we just pass it text)
+                //
+                def response = httpRequest(
+                    timeout: 10,
+                    authentication: github_cred,
+                    url: "${github_repo}/collaborators")
+                def collab_data = readJSON(
+                    text: response.content)
+                collab_found = false;
+                for (collaborator in collab_data) {
+                    if (collaborator['login'] == "$CHANGE_AUTHOR") {
+                        echo "$CHANGE_AUTHOR is a collaborator!"
+                        collab_found = true;
+                        break;
+                    }
+                }
+
+                if (! collab_found) {
+                    manager.addShortText(
+                        "Author of this change is not a collaborator!",
+                        "Crimson",
+                        "white",
+                        "0px",
+                        "white")
+                    all_status['startup'] =
+                        [false, 'Author Check', "$CHANGE_AUTHOR is not a collaborator!"]
+                    error "$CHANGE_AUTHOR does not appear to be a collaborator...bailing on this build"
+                }
+            }
+        }
+    }
+
+    stage ('Parallel Build') {
+        def variants = [
+            'coverage',
+            'clang.debug.unity',
+            'clang.debug.nounity',
+            'gcc.debug.unity',
+            'gcc.debug.nounity',
+            'clang.release.unity',
+            'gcc.release.unity'] as String[]
+
+        // create a map of all builds
+        // that we want to run. The map
+        // is string keys and node{} object values
+        def builds = [:]
+        for (int index = 0; index < variants.size(); index++) {
+            def bldtype = variants[index]
+            builds[bldtype] = {
+                node('rippled-dev') {
+                    checkout scm
+                    dir ('build') {
+                        deleteDir()
+                    }
+                    def cdir = upDir(pwd())
+                    echo "BASEDIR: ${cdir}"
+                    def compiler = getCompiler(bldtype)
+                    def target = getTarget(bldtype)
+                    if (compiler == "coverage") {
+                        compiler = 'gcc'
+                    }
+                    echo "COMPILER: ${compiler}"
+                    echo "TARGET: ${target}"
+                    def clang_cc  =
+                        (compiler == "clang") ? "${LLVM_ROOT}/bin/clang" : ''
+                    def clang_cxx =
+                        (compiler == "clang") ? "${LLVM_ROOT}/bin/clang++" : ''
+                    def ucc = isNoUnity(target) ? 'true' : 'false'
+                    echo "USE_CC: ${ucc}"
+                    withEnv(["CCACHE_BASEDIR=${cdir}",
+                             "CCACHE_NOHASHDIR=true",
+                             'LCOV_ROOT=""',
+                             "TARGET=${target}",
+                             "CC=${compiler}",
+                             'BUILD=cmake',
+                             'VERBOSE_BUILD=true',
+                             "CLANG_CC=${clang_cc}",
+                             "CLANG_CXX=${clang_cxx}",
+                             "USE_CCACHE=${ucc}"])
+                    {
+                        myStage(bldtype)
+                        try {
+                            sh "ccache -s > ${bldtype}.txt"
+                            // the devtoolset from SCL gives us a recent gcc. It's
+                            // not strictly needed when we are building with clang,
+                            // but it doesn't seem to interfere either
+                            sh "source /opt/rh/devtoolset-6/enable && " +
+                               "(/usr/bin/time -p ./bin/ci/ubuntu/build-and-test.sh 2>&1) 2>&1 " +
+                               ">> ${bldtype}.txt"
+                            sh "ccache -s >> ${bldtype}.txt"
+                        }
+                        finally {
+                            def outstr = readFile("${bldtype}.txt")
+                            def st = getResults(outstr)
+                            def time = getTime(outstr)
+                            def fail_count = getFailures(outstr)
+                            outstr = null
+                            def txtcolor =
+                                fail_count == 0 ? "DarkGreen" : "Crimson"
+                            def shortbld = bldtype
+                            shortbld = shortbld.replace('debug', 'dbg')
+                            shortbld = shortbld.replace('release', 'rel')
+                            shortbld = shortbld.replace('unity', 'un')
+                            manager.addShortText(
+                                "${shortbld}: ${st}, t: ${time}",
+                                txtcolor,
+                                "white",
+                                "0px",
+                                "white")
+                            archive("${bldtype}.txt")
+                            lock('rippled_dev_status') {
+                                all_status[bldtype] =
+                                    [fail_count == 0, bldtype, "${st}, t: ${time}"]
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        parallel builds
+    }
+}
+finally {
+    // anything here should run always...
+    stage ('Final Status') {
+        node {
+            def start_time = new Date()
+            def sdf = new SimpleDateFormat("yyyyMMdd - HH:mm:ss")
+            def datestamp = sdf.format(start_time)
+
+            def results = """
+## Jenkins Build Summary
+
+Built from [this commit](https://github.com/ripple/rippled/commit/${commit_id})
+
+Built at __${datestamp}__
+
+### Test Results
+
+Build Type | Result | Status
+---------- | ------ | ------
+"""
+            for ( e in all_status) {
+                results += e.value[1] + " | " + e.value[2] + " | " +
+                    (e.value[0] ? "PASS :white_check_mark: " : "FAIL :red_circle: ") + "\n"
+            }
+            results += "\n"
+            echo "FINAL BUILD RESULTS"
+            echo results
+
+            try {
+                def url_comment = ""
+                if (env.CHANGE_ID && env.CHANGE_ID ==~ /\d+/) {
+                    //
+                    // CHANGE_ID indicates we are building a PR
+                    // find PR comments
+                    //
+                    def resp = httpRequest(
+                        timeout: 10,
+                        authentication: github_cred,
+                        url: "${github_repo}/pulls/$CHANGE_ID")
+                    def result = readJSON(text: resp.content)
+                    //
+                    // follow issue comments link
+                    //
+                    url_comment = result['_links']['issue']['href'] + '/comments'
+                }
+                else {
+                    //
+                    // if not a PR, just search comments for our commit ID
+                    //
+                    url_comment =
+                        "${github_repo}/commits/${commit_id}/comments"
+                }
+
+                def response = httpRequest(
+                    timeout: 10,
+                    authentication: github_cred,
+                    url: url_comment)
+                def data = readJSON(text: response.content)
+                def comment_id = 0
+                def mode = 'POST'
+                // see if we can find and existing comment here with
+                // a heading that matches ours...
+                for (comment in data) {
+                    if (comment['body'] =~ /(?m)^##\s+Jenkins Build/) {
+                        comment_id = comment['id']
+                        echo "existing status comment ${comment_id} found"
+                        url_comment = comment['url']
+                        mode = 'PATCH'
+                        break;
+                    }
+                }
+
+                if (comment_id == 0) {
+                    echo "no existing status comment found"
+                }
+
+                def body = JsonOutput.toJson([
+                    body: results
+                ])
+
+                response = httpRequest(
+                    timeout: 10,
+                    authentication: github_cred,
+                    url: url_comment,
+                    contentType: 'APPLICATION_JSON',
+                    httpMode: mode,
+                    requestBody: body)
+            }
+            catch (any) {
+                echo "had a problem interacting with github...status is probably not updated"
+            }
+        }
+    }
+}
+
+// ---------------
+// util functions
+// ---------------
+def myStage(name) {
+    echo """
++++++++++++++++++++++++++++++++++++++++++
+  >> building ${name}
++++++++++++++++++++++++++++++++++++++++++
+"""
+}
+
+def printGitInfo(id, log) {
+    echo """
++++++++++++++++++++++++++++++++++++++++++
+  >> Building commit ID ${id}
+  >>
+${log}
++++++++++++++++++++++++++++++++++++++++++
+"""
+}
+
+@NonCPS
+def getResults(text) {
+    // example:
+    /// 194.5s, 154 suites, 948 cases, 360485 tests total, 0 failures
+    def matcher = text =~ /(\d+) cases, (\d+) tests total, (\d+) (failure(s?))/
+    matcher ? matcher[0][1] + " cases, " + matcher[0][3] + " failed" : "no test results"
+}
+
+def getFailures(text) {
+    // example:
+    /// 194.5s, 154 suites, 948 cases, 360485 tests total, 0 failures
+    def matcher = text =~ /(\d+) tests total, (\d+) (failure(s?))/
+    // if we didn't match, then return 1 since something is
+    // probably wrong, e.g. maybe the build failed...
+    matcher ? matcher[0][2] as Integer : 1i
+}
+
+@NonCPS
+def getCompiler(bld) {
+    def matcher = bld =~ /^(.+?)\.(.+)$/
+    matcher ? matcher[0][1] : bld
+}
+
+@NonCPS
+def isNoUnity(bld) {
+    def matcher = bld =~ /\.nounity\s*$/
+    matcher ? true : false
+}
+
+@NonCPS
+def getTarget(bld) {
+    def matcher = bld =~ /^(.+?)\.(.+)$/
+    matcher ? matcher[0][2] : bld
+}
+
+// because I can't seem to find path manipulation
+// functions in groovy....
+@NonCPS
+def upDir(path) {
+    def matcher = path =~ /^(.+)\/(.+?)/
+    matcher ? matcher[0][1] : path
+}
+
+@NonCPS
+def getTime(text) {
+    // look for text following a label 'real' for
+    // wallclock time. Some `time`s report fractional
+    // seconds and we can omit those in what we report
+    def matcher = text =~ /(?m)^real\s+(.+)\.(\d+?)[s]?/
+    matcher ? matcher[0][1] + "s" : "n/a"
+}
+

RELEASENOTES.md

@@ -11,6 +11,80 @@ If you are using Red Hat Enterprise Linux 7 or CentOS 7, you can [update using `
 
 # Releases
 
+## Version 0.90.0
+
+The `rippled` 0.90.0 release introduces several features and enhancements that improve the reliability, scalability and security of the XRP Ledger.
+
+Highlights of this release include:
+
+- The `DepositAuth` amendment, which lets an account strictly reject any incoming money from transactions sent by other accounts.
+- The `Checks` amendment, which allows users to create deferred payments that can be cancelled or cashed by their intended recipients.
+- **History Sharding**, which allows `rippled` servers to distribute historical ledger data if they agree to dedicate storage for segments of ledger history.
+- New **Preferred Ledger by Branch** semantics which improve the logic that allow a server to decide which ledger it should base future ledgers on when there are multiple candidates.
+
+**New and Updated Features**
+
+- Add support for Deposit Authorization account root flag ([#2239](https://github.com/ripple/rippled/issues/2239))
+- Implement history shards ([#2258](https://github.com/ripple/rippled/issues/2258))
+- Preferred ledger by branch ([#2300](https://github.com/ripple/rippled/issues/2300))
+- Redesign Consensus Simulation Framework ([#2209](https://github.com/ripple/rippled/issues/2209))
+- Tune for higher transaction processing ([#2294](https://github.com/ripple/rippled/issues/2294))
+- Optimize queries for `account_tx` to work around SQLite query planner ([#2312](https://github.com/ripple/rippled/issues/2312))
+- Allow `Journal` to be copied/moved ([#2292](https://github.com/ripple/rippled/issues/2292))
+- Cleanly report invalid `[server]` settings ([#2305](https://github.com/ripple/rippled/issues/2305))
+- Improve log scrubbing ([#2358](https://github.com/ripple/rippled/issues/2358))
+- Update `rippled-example.cfg` ([#2307](https://github.com/ripple/rippled/issues/2307))
+- Force json commands to be objects ([#2319](https://github.com/ripple/rippled/issues/2319))
+- Fix cmake clang build for sanitizers ([#2325](https://github.com/ripple/rippled/issues/2325))
+- Allow `account_objects` RPC to filter by “check” ([#2356](https://github.com/ripple/rippled/issues/2356))
+- Limit nesting of json commands ([#2326](https://github.com/ripple/rippled/issues/2326))
+- Unit test that `sign_for` returns a correct hash ([#2333](https://github.com/ripple/rippled/issues/2333))
+- Update Visual Studio build instructions ([#2355](https://github.com/ripple/rippled/issues/2355))
+- Force boost static linking for MacOS builds ([#2334](https://github.com/ripple/rippled/issues/2334))
+- Update MacOS build instructions ([#2342](https://github.com/ripple/rippled/issues/2342))
+- Add dev docs generation to Jenkins ([#2343](https://github.com/ripple/rippled/issues/2343))
+- Poll if process is still alive in Test.py ([#2290](https://github.com/ripple/rippled/issues/2290))
+- Remove unused `beast::currentTimeMillis()` ([#2345](https://github.com/ripple/rippled/issues/2345))
+
+
+**Bug Fixes**
+- Improve error message on mistyped command ([#2283](https://github.com/ripple/rippled/issues/2283))
+- Add missing includes ([#2368](https://github.com/ripple/rippled/issues/2368))
+- Link boost statically only when requested ([#2291](https://github.com/ripple/rippled/issues/2291))
+- Unit test logging fixes ([#2293](https://github.com/ripple/rippled/issues/2293))
+- Fix Jenkins pipeline for branches ([#2289](https://github.com/ripple/rippled/issues/2289))
+- Avoid AppVeyor stack overflow ([#2344](https://github.com/ripple/rippled/issues/2344))
+- Reduce noise in log ([#2352](https://github.com/ripple/rippled/issues/2352))
+
+
+## Version 0.81.0
+
+The `rippled` 0.81.0 release introduces changes that improve the scalability of the XRP Ledger and transitions the recommended validator configuration to a new hosted site, as described in Ripple's [Decentralization Strategy Update](https://ripple.com/dev-blog/decentralization-strategy-update/) post.
+
+**New and Updated Features**
+
+- New hosted validator configuration.
+
+
+**Bug Fixes**
+
+- Optimize queries for account_tx to work around SQLite query planner ([#2312](https://github.com/ripple/rippled/issues/2312))
+
+
+## Version 0.80.2
+
+The `rippled` 0.80.2 release introduces changes that improve the scalability of the XRP Ledger.
+
+**New and Updated Features**
+
+This release has no new features.
+
+**Bug Fixes**
+
+- Do not dispatch a transaction received from a peer for processing if it has already been dispatched within the past ten seconds.
+- Increase the number of transaction handlers that can be in flight in the job queue and decrease the relative cost for peers to share transaction and ledger data.
+- Make better use of resources by adjusting the number of threads we initialize, by reverting commit [#68b8ffd](https://github.com/ripple/rippled/commit/68b8ffdb638d07937f841f7217edeb25efdb3b5d).
+
 ## Version 0.80.1
 
 The `rippled` 0.80.1 release provides several enhancements in support of published validator lists and corrects several bugs.
@@ -57,8 +131,6 @@ Highlights of this release include:
 - Fix an issue where `setAmendmentBlocked` is only called when processing the `EnableAmendment` transaction for the amendment ([#2137](https://github.com/ripple/rippled/issues/2137))
 - Track escrow in recipient's owner directory ([#2212](https://github.com/ripple/rippled/issues/2212))
 
-**New and Updated Features**
-
 ## Version 0.70.2
 
 The `rippled` 0.70.2 release corrects an emergent behavior which causes large numbers of transactions to get

SConstruct

@@ -445,7 +445,8 @@ def add_sanitizer (toolchain, env):
         raise Exception("Sanitizers are only supported for gcc and clang")
     env.Append(CCFLAGS=['-fsanitize='+san, '-fno-omit-frame-pointer'])
     env.Append(LINKFLAGS=['-fsanitize='+san])
-    add_static_libs(env, [san_to_lib[san]])
+    if toolchain in['gcc']:
+        add_static_libs(env, [san_to_lib[san]])
     env.Append(CPPDEFINES=['SANITIZER='+san_to_lib[san].upper()])
 
 def add_boost_and_protobuf(toolchain, env):
@@ -563,7 +564,8 @@ def config_env(toolchain, variant, env):
         env.Append(CXXFLAGS=[
             '-frtti',
             '-std=c++14',
-            '-Wno-invalid-offsetof'
+            '-Wno-invalid-offsetof',
+            '-Wdeprecated'
             ])
 
         env.Append(CPPDEFINES=['_FILE_OFFSET_BITS=64'])
@@ -576,7 +578,6 @@ def config_env(toolchain, variant, env):
         # These should be the same regardless of platform...
         if Beast.system.osx:
             env.Append(CCFLAGS=[
-                '-Wno-deprecated',
                 '-Wno-deprecated-declarations',
                 '-Wno-unused-function',
                 ])
@@ -613,7 +614,8 @@ def config_env(toolchain, variant, env):
             'boost_program_options',
             'boost_regex',
             'boost_system',
-            'boost_thread'
+            'boost_thread',
+            'boost_serialization'
         ]
         env.Append(LIBS=['dl'])
 
@@ -978,6 +980,7 @@ def get_classic_sources(toolchain):
     append_sources(result, *list_sources('src/test/shamap', '.cpp'))
     append_sources(result, *list_sources('src/test/jtx', '.cpp'))
     append_sources(result, *list_sources('src/test/csf', '.cpp'))
+    append_sources(result, *list_sources('src/test/unit_test', '.cpp'))
 
 
     if use_shp(toolchain):

appveyor.yml

@@ -4,9 +4,9 @@ environment:
 
   # We bundle up protoc.exe and only the parts of boost and openssl we need so
   # that it's a small download. We also use appveyor's free cache, avoiding fees
-  # downloading from S3 each time. 
+  # downloading from S3 each time.
   # TODO: script to create this package.
-  RIPPLED_DEPS_PATH: rippled_deps15.02
+  RIPPLED_DEPS_PATH: rippled_deps17.01
   RIPPLED_DEPS_URL: https://ripple.github.io/Downloads/appveyor/%RIPPLED_DEPS_PATH%.zip
 
   # Other dependencies we just download each time.
@@ -21,6 +21,11 @@ environment:
   BOOST_ROOT: C:/%RIPPLED_DEPS_PATH%/boost
   OPENSSL_ROOT: C:/%RIPPLED_DEPS_PATH%/openssl
 
+  # We've had trouble with AppVeyor apparently not having a stack as large
+  # as the *nix CI platforms.  AppVeyor support suggested that we try
+  # GCE VMs.  The following line is supposed to enable that VM type.
+  appveyor_build_worker_cloud: gce
+
   matrix:
   # This build works, but our current Appveyor config runs matrix builds
   # sequentially, and the one build is already slow enough.
@@ -30,7 +35,7 @@ environment:
     target: msvc.debug
     buildconfig: Debug
 
-os: Visual Studio 2015
+os: Visual Studio 2017
 
 # At the end of each successful build we cache this directory.
 # https://www.appveyor.com/docs/build-cache/
@@ -103,7 +108,7 @@ build_script:
           "$cmake_target"
           New-Item -ItemType Directory -Force -Path "build/$cmake_target"
           Push-Location "build/$cmake_target"
-          cmake -G"Visual Studio 14 2015 Win64" -Dtarget="$cmake_target" ../..
+          cmake -G"Visual Studio 15 2017 Win64" -Dtarget="$cmake_target" ../..
           if ($LastExitCode -ne 0) { throw "CMake failed" }
           cmake --build . --config $env:buildconfig -- -m
           if ($LastExitCode -ne 0) { throw "CMake build failed" }
@@ -127,7 +132,7 @@ test_script:
   - ps: |
         & {
           # Run the rippled unit tests
-          & $exe --unittest --quiet --unittest-log
+          & $exe --unittest --unittest-log
           # https://connect.microsoft.com/PowerShell/feedback/details/751703/option-to-stop-script-if-command-line-exe-fails
           if ($LastExitCode -ne 0) { throw "Unit tests failed" }
         }

bin/ci/ubuntu/build-and-test.sh

@@ -10,26 +10,45 @@ echo "using TARGET: $TARGET"
 
 # Ensure APP defaults to rippled if it's not set.
 : ${APP:=rippled}
+echo "using APP: $APP"
 
 JOBS=${NUM_PROCESSORS:-2}
-if [[ ${TARGET} == *.nounity ]]; then
-    JOBS=$((2*${JOBS}))
-fi
+JOBS=$((JOBS+1))
 
 if [[ ${BUILD:-scons} == "cmake" ]]; then
   echo "cmake building ${APP}"
+  CMAKE_EXTRA_ARGS=" -DCMAKE_VERBOSE_MAKEFILE=ON"
   CMAKE_TARGET=$CC.$TARGET
+  BUILDARGS=" -j${JOBS}"
+  if [[ ${VERBOSE_BUILD:-} == true ]]; then
+    # TODO: if we use a different generator, this
+    # option to build verbose would need to change:
+    BUILDARGS+=" verbose=1"
+  fi
   if [[ ${CI:-} == true ]]; then
     CMAKE_TARGET=$CMAKE_TARGET.ci
   fi
+  if [[ ${USE_CCACHE:-} == true ]]; then
+    echo "using ccache with basedir [${CCACHE_BASEDIR:-}]"
+    CMAKE_EXTRA_ARGS+=" -DCMAKE_CXX_COMPILER_LAUNCHER=ccache"
+  fi
+  if [ -d "build/${CMAKE_TARGET}" ]; then
+    rm -rf "build/${CMAKE_TARGET}"
+  fi
   mkdir -p "build/${CMAKE_TARGET}"
   pushd "build/${CMAKE_TARGET}"
-  cmake ../.. -Dtarget=$CMAKE_TARGET
-  cmake --build . -- -j${JOBS}
+  cmake ../.. -Dtarget=$CMAKE_TARGET ${CMAKE_EXTRA_ARGS}
+  cmake --build . -- $BUILDARGS
+  if [[ ${BUILD_BOTH:-} == true ]]; then
+    if [[ ${TARGET} == *.unity ]]; then
+      cmake --build . --target rippled_classic -- $BUILDARGS
+    else
+      cmake --build . --target rippled_unity -- $BUILDARGS
+    fi
+  fi
   popd
   export APP_PATH="$PWD/build/${CMAKE_TARGET}/${APP}"
   echo "using APP_PATH: $APP_PATH"
-
 else
   export APP_PATH="$PWD/build/$CC.$TARGET/${APP}"
   echo "using APP_PATH: $APP_PATH"
@@ -65,26 +84,31 @@ if [[ $TARGET == "coverage" ]]; then
   export PATH=$PATH:$LCOV_ROOT/usr/bin
 
   # Create baseline coverage data file
-  lcov --no-external -c -i -d . -o baseline.info
+  lcov --no-external -c -i -d . -o baseline.info | grep -v "ignoring data for external file"
 fi
 
-if [[ ${TARGET} == debug ]]; then
-    # Execute unit tests under gdb, printing a call stack
-    # if we get a crash.
-    $GDB_ROOT/bin/gdb -return-child-result -quiet -batch \
-                      -ex "set env MALLOC_CHECK_=3" \
-                      -ex "set print thread-events off" \
-                      -ex run \
-                      -ex "thread apply all backtrace full" \
-                      -ex "quit" \
-                      --args $APP_PATH $APP_ARGS
+if [[ ${SKIP_TESTS:-} == true ]]; then
+  echo "skipping tests for ${TARGET}"
+  exit
+fi
+
+if [[ $TARGET == debug* ]]; then
+  # Execute unit tests under gdb, printing a call stack
+  # if we get a crash.
+  $GDB_ROOT/bin/gdb -return-child-result -quiet -batch \
+                    -ex "set env MALLOC_CHECK_=3" \
+                    -ex "set print thread-events off" \
+                    -ex run \
+                    -ex "thread apply all backtrace full" \
+                    -ex "quit" \
+                    --args $APP_PATH $APP_ARGS
 else
-    $APP_PATH $APP_ARGS
+  $APP_PATH $APP_ARGS
 fi
 
 if [[ $TARGET == "coverage" ]]; then
   # Create test coverage data file
-  lcov --no-external -c -d . -o tests.info
+  lcov --no-external -c -d . -o tests.info | grep -v "ignoring data for external file"
 
   # Combine baseline and test coverage data
   lcov -a baseline.info -a tests.info -o lcov-all.info

bin/ci/ubuntu/install-dependencies.sh

@@ -67,8 +67,7 @@ tar xfvz lcov-1.12.tar.gz -C $HOME
 mkdir -p $LCOV_ROOT
 cd $HOME/lcov-1.12 && make install PREFIX=$LCOV_ROOT
 
-
-if [[ ${TARGET} == debug && ! -x ${GDB_ROOT}/bin/gdb ]]; then
+if [[ ${TARGET} == debug* && ! -x ${GDB_ROOT}/bin/gdb ]]; then
     pushd $HOME
     #install gdb
     wget https://ftp.gnu.org/gnu/gdb/gdb-8.0.tar.xz

doc/rippled-example.cfg

@@ -641,9 +641,7 @@
 #
 # [validators_file]
 #
-#   Path or name of a file that contains the validation public keys of nodes
-#   to always accept as validators as well as the minimum number of validators
-#   needed to accept consensus.
+#   Path or name of a file that determines the nodes to always accept as validators.
 #
 #   The contents of the file should include a [validators] and/or
 #   [validator_list_sites] and [validator_list_keys] entries.
@@ -836,6 +834,33 @@
 #   [import_db]     Settings for performing a one-time import (optional)
 #   [database_path]   Path to the book-keeping databases.
 #
+#   [shard_db]      Settings for the Shard Database (optional)
+#
+#   Format (without spaces):
+#       One or more lines of case-insensitive key / value pairs:
+#       <key> '=' <value>
+#       ...
+#
+#   Example:
+#       type=nudb
+#       path=db/nudb
+#
+#   The "type" field must be present and controls the choice of backend:
+#
+#   type = NuDB
+#
+#   type = RocksDB
+#
+#       The RocksDB backend also provides these optional parameters:
+#
+#       compression         0 for none, 1 for Snappy compression
+#
+#   Required keys:
+#       path                Location to store the database (all types)
+#
+#       max_size_gb         Maximum disk space the database will utilize (in gigabytes)
+#
+#
 #   There are 4 bookkeeping SQLite database that the server creates and
 #   maintains. If you omit this configuration setting, it will default to
 #   creating a directory called "db" located in the same place as your

doc/validators-example.txt

@@ -45,10 +45,11 @@
 #    02dd8b7075f64d77d9d2bdb88da364f29fcd975f9ea6f21894abcc7564efda8054
 #
 
-# Public keys of the validators that this rippled instance trusts.
-[validators]
-n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7
-n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj
-n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C
-n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS
-n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA
+# The default validator list publishers that the rippled instance
+# trusts
+
+[validator_list_sites]
+https://vl.ripple.com
+
+[validator_list_keys]
+ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734

docs/consensus.qbk

@@ -458,10 +458,12 @@ struct Ledger
 {
   using ID = ...;
 
+  using Seq = //std::uint32_t?...;
+
   ID const & id() const;
 
   // Sequence number that is 1 more than the parent ledger's seq()
-  std::size_t seq() const;
+  Seq seq() const;
 
   // Whether the ledger's close time was a non-trivial consensus result
   bool closeAgree() const;
@@ -633,14 +635,14 @@ struct Adaptor
     // Propose the position to peers.
     void propose(ConsensusProposal<...> const & pos);
 
-    // Relay a received peer proposal on to other peer's.
-    void relay(PeerPosition_t const & pos);
+    // Share a received peer proposal with other peers.
+    void share(PeerPosition_t const & pos);
 
-    // Relay a disputed transaction to peers
-    void relay(TxSet::Tx const & tx);
+    // Share a disputed transaction with peers
+    void share(TxSet::Tx const & tx);
 
-    // Realy given transaction set with peers
-    void relay(TxSet const &s);
+    // Share given transaction set with peers
+    void share(TxSet const &s);
 
     //... implementation specific
 };
@@ -649,9 +651,9 @@ struct Adaptor
 The implementing class hides many details of the peer communication
 model from the generic code.
 
-* The =relay= member functions are responsible for sharing the given type with a
+* The =share= member functions are responsible for sharing the given type with a
   node's peers, but are agnostic to the mechanism. Ideally, messages are delivered
-  faster than =LEDGER_GRANULARITY=.
+  faster than =LEDGER_GRANULARITY=. 
 * The generic code does not specify how transactions are submitted by clients,
   propagated through the network or stored in the open ledger. Indeed, the open
   ledger is only conceptual from the perspective of the generic code---the

docs/source.dox

@@ -114,6 +114,7 @@ INPUT                  = \
     ../src/ripple/consensus/ConsensusTypes.h \
     ../src/ripple/consensus/DisputedTx.h \
     ../src/ripple/consensus/LedgerTiming.h \
+    ../src/ripple/consensus/LedgerTrie.h \
     ../src/ripple/consensus/Validations.h \
     ../src/ripple/consensus/ConsensusParms.h \
     ../src/ripple/app/consensus/RCLCxTx.h \

src/beast/include/beast/core/detail/type_traits.hpp

@@ -9,6 +9,7 @@
 #define BEAST_DETAIL_TYPE_TRAITS_HPP
 
 #include <beast/core/error.hpp>
+#include <boost/asio/basic_streambuf.hpp>
 #include <boost/asio/buffer.hpp>
 #include <boost/asio/io_service.hpp>
 #include <iterator>
@@ -16,31 +17,6 @@
 #include <type_traits>
 #include <string>
 
-// A few workarounds to keep things working
-
-namespace boost {
-namespace asio {
-
-// for has_get_io_service
-class io_service;
-
-// for is_dynamic_buffer
-template<class Allocator>
-class basic_streambuf;
-
-namespace detail {
-
-// for is_buffer_sequence
-template<class Buffer, class Buffers>
-class consuming_buffers;
-
-} // detail
-
-} // asio
-} // boost
-
-//------------------------------------------------------------------------------
-
 namespace beast {
 namespace detail {
 

src/beast/include/beast/core/impl/buffer_cat.ipp

@@ -30,10 +30,10 @@ class buffer_cat_view<Bn...>::const_iterator
             "BufferSequence requirements not met");
 #endif
 
-    std::size_t n_;
+    std::size_t n_{};
     std::tuple<Bn...> const* bn_;
     std::array<char, detail::max_sizeof<
-        typename Bn::const_iterator...>()> buf_;
+        typename Bn::const_iterator...>()> buf_{};
 
     friend class buffer_cat_view<Bn...>;
 

src/beast/include/beast/core/type_traits.hpp

@@ -154,6 +154,7 @@ struct is_dynamic_buffer<T, detail::void_t<decltype(
 {
 };
 
+#if BOOST_VERSION < 106600
 // Special case for Boost.Asio which doesn't adhere to
 // net-ts but still provides a read_size_helper so things work
 template<class Allocator>
@@ -163,6 +164,9 @@ struct is_dynamic_buffer<
 };
 #endif
 
+
+#endif
+
 //------------------------------------------------------------------------------
 //
 // Handler concepts

src/beast/include/beast/http/detail/chunk_encode.hpp

@@ -70,6 +70,14 @@ public:
         copy(other);
     }
 
+    /// Copy assignment
+    chunk_header& operator=(chunk_header const& other)
+    {
+        if (this != &other)
+            copy(other);
+        return *this;
+    }
+
     /** Construct a chunk header
 
         @param n The number of octets in this chunk.

src/beast/include/beast/http/impl/fields.ipp

@@ -119,8 +119,6 @@ public:
         using value_type =
             typename const_iterator::value_type;
 
-        field_range(field_range const&) = default;
-
         field_range(iter_type first, iter_type last)
             : first_(first)
             , last_(last)

src/beast/include/beast/websocket/detail/frame.hpp

@@ -264,7 +264,7 @@ read(close_reason& cr,
     }
     consuming_buffers<Buffers> cb(bs);
     {
-        std::uint8_t b[2];
+        std::uint8_t b[2] = {0, 0};
         buffer_copy(buffer(b), cb);
         cr.code = big_uint16_to_native(&b[0]);
         cb.consume(2);

src/lz4/.gitattributes

@@ -8,8 +8,14 @@
 # Denote files that should not be modified.
 *.odt binary
 *.png binary
-# Visual Studio
-*.sln binary
-*.suo binary
-*.vcxproj* binary
 
+# Visual Studio
+*.sln text eol=crlf
+*.vcxproj* text eol=crlf
+*.vcproj* text eol=crlf
+*.suo binary
+*.rc text eol=crlf
+
+# Windows
+*.bat text eol=crlf
+*.cmd text eol=crlf

src/lz4/.gitignore

@@ -0,0 +1,31 @@
+# Object files
+*.o
+*.ko
+
+# Libraries
+*.lib
+*.a
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+*.dSYM   # apple
+
+# Executables
+*.exe
+*.out
+*.app
+lz4
+
+# IDE / editors files
+.clang_complete
+_codelite/
+_codelite_lz4/
+bin/
+*.zip
+
+# Mac
+.DS_Store
+*.dSYM

src/lz4/.travis.yml

@@ -1,35 +1,150 @@
 language: c
-compiler: gcc
-script: make test-travis
-before_install:
-  - sudo apt-get update  -qq
-  - sudo apt-get install -qq gcc-arm-linux-gnueabi
-  - sudo apt-get install -qq clang
-  - sudo apt-get install -qq g++-multilib
-  - sudo apt-get install -qq gcc-multilib
-  - sudo apt-get install -qq valgrind
-  - sudo apt-get install -qq python3
-
-env:
-  - LZ4_TRAVIS_CI_ENV=travis-install
-  - LZ4_TRAVIS_CI_ENV=streaming-examples
-  - LZ4_TRAVIS_CI_ENV=cmake
-  - LZ4_TRAVIS_CI_ENV=clangtest
-  - LZ4_TRAVIS_CI_ENV=sanitize
-  - LZ4_TRAVIS_CI_ENV=staticAnalyze
-  - LZ4_TRAVIS_CI_ENV=gpptest
-  - LZ4_TRAVIS_CI_ENV=armtest
-  - LZ4_TRAVIS_CI_ENV=versionstest
-  - LZ4_TRAVIS_CI_ENV=test-lz4
-  - LZ4_TRAVIS_CI_ENV=test-lz4c
-  - LZ4_TRAVIS_CI_ENV=test-lz4c32
-  - LZ4_TRAVIS_CI_ENV=test-fullbench
-  - LZ4_TRAVIS_CI_ENV=test-fullbench32
-  - LZ4_TRAVIS_CI_ENV=test-fuzzer
-  - LZ4_TRAVIS_CI_ENV=test-fuzzer32
-  - LZ4_TRAVIS_CI_ENV=test-frametest
-  - LZ4_TRAVIS_CI_ENV=test-frametest32
-  - LZ4_TRAVIS_CI_ENV=test-mem
-
 matrix:
   fast_finish: true
+  include:
+    # OS X Mavericks
+    - os: osx
+      install:
+        - export CC=clang
+      env: Ubu=OS_X_Mavericks Cmd='make -C tests test-lz4 MOREFLAGS="-Werror -Wconversion -Wno-sign-conversion" && CFLAGS=-m32 make -C tests clean test-lz4-contentSize' COMPILER=clang
+
+    # Container-based 12.04 LTS Server Edition 64 bit (doesn't support 32-bit includes)
+    - os: linux
+      sudo: false
+      env: Ubu=12.04cont Cmd='make -C tests test-lz4 test-lz4c test-fasttest test-fullbench' COMPILER=cc
+
+    - os: linux
+      sudo: false
+      env: Ubu=12.04cont Cmd='make -C tests test-frametest test-fuzzer' COMPILER=cc
+
+    - os: linux
+      sudo: false
+      env: Ubu=12.04cont Cmd="make gpptest && make clean examples && make clean cmake && make clean travis-install && make clean clangtest" COMPILER=cc
+
+
+    # 14.04 LTS Server Edition 64 bit
+    - env: Ubu=14.04 Cmd='make -C tests test MOREFLAGS=-mx32' COMPILER=cc
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - libc6-dev-i386
+            - gcc-multilib
+
+    - env: Ubu=14.04 Cmd='make usan' COMPILER=clang
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - clang
+
+    - env: Ubu=14.04 Cmd='make c_standards && make -C tests test-lz4 test-mem' COMPILER=cc
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - valgrind
+
+    - env: Ubu=14.04 Cmd='make -C tests test-lz4c32 test-fullbench32 versionsTest' COMPILER=cc
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - python3
+            - libc6-dev-i386
+            - gcc-multilib
+
+    - env: Ubu=14.04 Cmd='make -C tests test-frametest32 test-fuzzer32' COMPILER=cc
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - libc6-dev-i386
+            - gcc-multilib
+
+    - env: Ubu=14.04 Cmd='make c_standards CC=gcc-6 && make -C tests test-lz4 CC=gcc-6 MOREFLAGS=-Werror' COMPILER=gcc-6
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - gcc-6
+
+    - env: Ubu=14.04 Cmd='make platformTest CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static && make platformTest CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static' COMPILER=arm-linux-gnueabi-gcc
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - qemu-system-arm
+            - qemu-user-static
+            - gcc-arm-linux-gnueabi
+            - libc6-dev-armel-cross
+            - gcc-aarch64-linux-gnu
+            - libc6-dev-arm64-cross
+
+    - env: Ubu=14.04 Cmd='make -C tests test-lz4 clean test-lz4c32 CC=gcc-5 MOREFLAGS=-Werror' COMPILER=gcc-5
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - libc6-dev-i386
+            - gcc-multilib
+            - gcc-5
+            - gcc-5-multilib
+
+    - env: Ubu=14.04 Cmd='make -C tests test-lz4 CC=clang-3.8' COMPILER=clang-3.8
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+          packages:
+            - clang-3.8
+
+    - env: Ubu=14.04 Cmd='make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static && make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS=-m64' COMPILER=powerpc-linux-gnu-gcc
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - qemu-system-ppc
+            - qemu-user-static
+            - gcc-powerpc-linux-gnu
+
+    - env: Ubu=14.04 Cmd='make staticAnalyze' COMPILER=clang
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          packages:
+            - clang
+
+    - env: Ubu=14.04 Cmd='make clean all CC=gcc-4.4 MOREFLAGS=-Werror && make clean && CFLAGS=-fPIC LDFLAGS="-pie -fPIE -D_FORTIFY_SOURCE=2" make -C programs' COMPILER=gcc-4.4
+      dist: trusty
+      sudo: required
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - libc6-dev-i386
+            - gcc-multilib
+            - gcc-4.4
+
+script:
+  - echo Cmd=$Cmd
+  - $COMPILER -v
+  - sh -c "$Cmd"

src/lz4/INSTALL

@@ -0,0 +1,15 @@
+Installation
+=============
+
+```
+make
+make install     # this command may require root access
+```
+
+LZ4's `Makefile` supports standard [Makefile conventions],
+including [staged installs], [redirection], or [command redefinition].
+
+[Makefile conventions]: https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html
+[staged installs]: https://www.gnu.org/prep/standards/html_node/DESTDIR.html
+[redirection]: https://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+[command redefinition]: https://www.gnu.org/prep/standards/html_node/Utilities-in-Makefiles.html

src/lz4/Makefile

@@ -1,19 +1,21 @@
 # ################################################################
 # LZ4 - Makefile
-# Copyright (C) Yann Collet 2011-2015
+# Copyright (C) Yann Collet 2011-2016
 # All rights reserved.
-# 
+#
+# This Makefile is validated for Linux, macOS, *BSD, Hurd, Solaris, MSYS2 targets
+#
 # BSD license
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
-# 
+#
 # * Redistributions of source code must retain the above copyright notice, this
 #   list of conditions and the following disclaimer.
-# 
+#
 # * Redistributions in binary form must reproduce the above copyright notice, this
 #   list of conditions and the following disclaimer in the documentation and/or
 #   other materials provided with the distribution.
-# 
+#
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
@@ -24,103 +26,156 @@
 # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-# 
+#
 # You can contact the author at :
-#  - LZ4 source repository : https://github.com/Cyan4973/lz4
+#  - LZ4 source repository : https://github.com/lz4/lz4
 #  - LZ4 forum froup : https://groups.google.com/forum/#!forum/lz4c
 # ################################################################
 
-# Version number
-export VERSION=130
-export RELEASE=r$(VERSION)
-
-DESTDIR?=
-PREFIX ?= /usr/local
-
-LIBDIR ?= $(PREFIX)/lib
-INCLUDEDIR=$(PREFIX)/include
-PRGDIR  = programs
 LZ4DIR  = lib
+PRGDIR  = programs
+TESTDIR = tests
+EXDIR   = examples
 
 
-# Select test target for Travis CI's Build Matrix
-ifneq (,$(filter test-%,$(LZ4_TRAVIS_CI_ENV)))
-TRAVIS_TARGET=prg-travis
-else
-TRAVIS_TARGET=$(LZ4_TRAVIS_CI_ENV)
-endif
-
 # Define nul output
 ifneq (,$(filter Windows%,$(OS)))
+EXT  = .exe
 VOID = nul
 else
+EXT  =
 VOID = /dev/null
 endif
 
 
-default: lz4programs
+.PHONY: default
+default: lib-release lz4-release
 
-all: 
-	@cd $(LZ4DIR); $(MAKE) -e all
-	@cd $(PRGDIR); $(MAKE) -e all
+.PHONY: all
+all: allmost manuals
 
-lz4programs:
-	@cd $(PRGDIR); $(MAKE) -e
+.PHONY: allmost
+allmost: lib lz4 examples
 
+.PHONY: lib lib-release
+lib lib-release:
+	@$(MAKE) -C $(LZ4DIR) $@
+
+.PHONY: lz4 lz4-release
+lz4 : lib
+lz4-release : lib-release
+lz4 lz4-release :
+	@$(MAKE) -C $(PRGDIR) $@
+	@cp $(PRGDIR)/lz4$(EXT) .
+
+.PHONY: examples
+examples: lib lz4
+	$(MAKE) -C $(EXDIR) test
+
+.PHONY: manuals
+manuals:
+	@$(MAKE) -C contrib/gen_manual $@
+
+.PHONY: clean
 clean:
-	@cd $(PRGDIR); $(MAKE) clean > $(VOID)
-	@cd $(LZ4DIR); $(MAKE) clean > $(VOID)
-	@cd examples;  $(MAKE) clean > $(VOID)
-	@cd test;      $(MAKE) clean > $(VOID)
+	@$(MAKE) -C $(LZ4DIR) $@ > $(VOID)
+	@$(MAKE) -C $(PRGDIR) $@ > $(VOID)
+	@$(MAKE) -C $(TESTDIR) $@ > $(VOID)
+	@$(MAKE) -C $(EXDIR) $@ > $(VOID)
+	@$(MAKE) -C contrib/gen_manual $@
+	@$(RM) lz4$(EXT)
 	@echo Cleaning completed
 
 
-#------------------------------------------------------------------------
-#make install is validated only for Linux, OSX, kFreeBSD and Hurd targets
-ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU))
+#-----------------------------------------------------------------------------
+# make install is validated only for Linux, OSX, BSD, Hurd and Solaris targets
+#-----------------------------------------------------------------------------
+ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD NetBSD DragonFly SunOS))
+HOST_OS = POSIX
 
-install:
-	@cd $(LZ4DIR); $(MAKE) -e install
-	@cd $(PRGDIR); $(MAKE) -e install
-
-uninstall:
-	@cd $(LZ4DIR); $(MAKE) uninstall
-	@cd $(PRGDIR); $(MAKE) uninstall
+.PHONY: install uninstall
+install uninstall:
+	@$(MAKE) -C $(LZ4DIR) $@
+	@$(MAKE) -C $(PRGDIR) $@
 
 travis-install:
-	sudo $(MAKE) install
-
-test:
-	@cd $(PRGDIR); $(MAKE) -e test
-
-test-travis: $(TRAVIS_TARGET)
+	$(MAKE) -j1 install DESTDIR=~/install_test_dir
 
 cmake:
-	@cd cmake_unofficial; cmake CMakeLists.txt; $(MAKE)
-
-gpptest: clean
-	$(MAKE) all CC=g++ CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
-
-clangtest: clean
-	$(MAKE) all CC=clang CPPFLAGS="-Werror -Wconversion -Wno-sign-conversion"
-
-sanitize: clean
-	$(MAKE) test CC=clang CPPFLAGS="-g -fsanitize=undefined" FUZZER_TIME="-T1mn" NB_LOOPS=-i1
-
-staticAnalyze: clean
-	scan-build --status-bugs -v $(MAKE) all CFLAGS=-g
-
-armtest: clean
-	cd lib; $(MAKE) -e all CC=arm-linux-gnueabi-gcc CPPFLAGS="-Werror"
-	cd programs; $(MAKE) -e bins CC=arm-linux-gnueabi-gcc CPPFLAGS="-Werror"
-
-versionstest: clean
-	@cd test; $(MAKE)
-
-streaming-examples:
-	cd examples; $(MAKE) -e test
-
-prg-travis:
-	@cd $(PRGDIR); $(MAKE) -e test-travis
+	@cd contrib/cmake_unofficial; cmake $(CMAKE_PARAMS) CMakeLists.txt; $(MAKE)
+
+endif
+
+
+ifneq (,$(filter MSYS%,$(shell uname)))
+HOST_OS = MSYS
+CMAKE_PARAMS = -G"MSYS Makefiles"
+endif
+
+
+#------------------------------------------------------------------------
+#make tests validated only for MSYS, Linux, OSX, kFreeBSD and Hurd targets
+#------------------------------------------------------------------------
+ifneq (,$(filter $(HOST_OS),MSYS POSIX))
+
+.PHONY: list
+list:
+	@$(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$' | xargs
+
+.PHONY: test
+test:
+	$(MAKE) -C $(TESTDIR) $@
+
+clangtest: clean
+	clang -v
+	@CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(LZ4DIR)  all CC=clang
+	@CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(PRGDIR)  all CC=clang
+	@CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(TESTDIR) all CC=clang
+
+clangtest-native: clean
+	clang -v
+	@CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(LZ4DIR)  all    CC=clang
+	@CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(PRGDIR)  native CC=clang
+	@CFLAGS="-O3 -Werror -Wconversion -Wno-sign-conversion" $(MAKE) -C $(TESTDIR) native CC=clang
+
+usan: clean
+	CC=clang CFLAGS="-O3 -g -fsanitize=undefined" $(MAKE) test FUZZER_TIME="-T1mn" NB_LOOPS=-i1
+
+usan32: clean
+	CFLAGS="-m32 -O3 -g -fsanitize=undefined" $(MAKE) test FUZZER_TIME="-T1mn" NB_LOOPS=-i1
+
+staticAnalyze: clean
+	CFLAGS=-g scan-build --status-bugs -v $(MAKE) all
+
+platformTest: clean
+	@echo "\n ---- test lz4 with $(CC) compiler ----"
+	@$(CC) -v
+	CFLAGS="-O3 -Werror"         $(MAKE) -C $(LZ4DIR) all
+	CFLAGS="-O3 -Werror -static" $(MAKE) -C $(PRGDIR) all
+	CFLAGS="-O3 -Werror -static" $(MAKE) -C $(TESTDIR) all
+	$(MAKE) -C $(TESTDIR) test-platform
+
+.PHONY: versionsTest
+versionsTest: clean
+	$(MAKE) -C $(TESTDIR) $@
+
+gpptest: clean
+	g++ -v
+	CC=g++ $(MAKE) -C $(LZ4DIR)  all CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
+	CC=g++ $(MAKE) -C $(PRGDIR)  all CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
+	CC=g++ $(MAKE) -C $(TESTDIR) all CFLAGS="-O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
+
+gpptest32: clean
+	g++ -v
+	CC=g++ $(MAKE) -C $(LZ4DIR)  all    CFLAGS="-m32 -O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
+	CC=g++ $(MAKE) -C $(PRGDIR)  native CFLAGS="-m32 -O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
+	CC=g++ $(MAKE) -C $(TESTDIR) native CFLAGS="-m32 -O3 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror"
+
+c_standards: clean
+	# note : lz4 is not C90 compatible, because it requires long long support
+	CFLAGS="-std=gnu90 -Werror" $(MAKE) clean allmost
+	CFLAGS="-std=c99   -Werror" $(MAKE) clean allmost
+	CFLAGS="-std=gnu99 -Werror" $(MAKE) clean allmost
+	CFLAGS="-std=c11   -Werror" $(MAKE) clean allmost
 
 endif

src/lz4/NEWS

@@ -1,3 +1,61 @@
+v1.8.0
+cli : fix : do not modify /dev/null permissions, reported by @Maokaman1
+cli : added GNU separator -- specifying that all following arguments are files
+API : added LZ4_compress_HC_destSize(), by Oleg (@remittor)
+API : added LZ4F_resetDecompressionContext()
+API : lz4frame : negative compression levels trigger fast acceleration, request by Lawrence Chan
+API : lz4frame : can control block checksum and dictionary ID
+API : fix : expose obsolete decoding functions, reported by Chen Yufei
+API : experimental : lz4frame_static : new dictionary compression API
+build : fix : static lib installation, by Ido Rosen
+build : dragonFlyBSD, OpenBSD, NetBSD supported
+build : LZ4_MEMORY_USAGE can be modified at compile time, through external define
+doc : Updated LZ4 Frame format to v1.6.0, restoring Dictionary-ID field
+doc : lz4 api manual, by Przemyslaw Skibinski
+
+v1.7.5
+lz4hc : new high compression mode : levels 10-12 compress more and slower, by Przemyslaw Skibinski
+lz4cat : fix : works with relative path (#284) and stdin (#285) (reported by @beiDei8z)
+cli : fix minor notification when using -r recursive mode
+API : lz4frame : LZ4F_frameBound(0) gives upper bound of *flush() and *End() operations (#290, #280)
+doc : markdown version of man page, by Takayuki Matsuoka (#279)
+build : Makefile : fix make -jX lib+exe concurrency (#277)
+build : cmake : improvements by Michał Górny (#296)
+
+v1.7.4.2
+fix : Makefile : release build compatible with PIE and customized compilation directives provided through environment variables (#274, reported by Antoine Martin)
+
+v1.7.4
+Improved : much better speed in -mx32 mode
+cli : fix : Large file support in 32-bits mode on Mac OS-X
+fix : compilation on gcc 4.4 (#272), reported by Antoine Martin
+
+v1.7.3
+Changed : moved to versioning; package, cli and library have same version number
+Improved: Small decompression speed boost
+Improved: Small compression speed improvement on 64-bits systems
+Improved: Small compression ratio and speed improvement on small files
+Improved: Significant speed boost on ARMv6 and ARMv7
+Fix : better ratio on 64-bits big-endian targets
+Improved cmake build script, by Evan Nemerson
+New liblz4-dll project, by Przemyslaw Skibinki
+Makefile: Generates object files (*.o) for faster (re)compilation on low power systems
+cli : new : --rm and --help commands
+cli : new : preserved file attributes, by Przemyslaw Skibinki
+cli : fix : crash on some invalid inputs
+cli : fix : -t correctly validates lz4-compressed files, by Nick Terrell
+cli : fix : detects and reports fread() errors, thanks to Hiroshi Fujishima report #243
+cli : bench : new : -r recursive mode
+lz4cat : can cat multiple files in a single command line (#184)
+Added : doc/lz4_manual.html, by Przemyslaw Skibinski
+Added : dictionary compression and frame decompression examples, by Nick Terrell
+Added : Debianization, by Evgeniy Polyakov
+
+r131
+New    : Dos/DJGPP target, thanks to Louis Santillan (#114)
+Added  : Example using lz4frame library, by Zbigniew Jędrzejewski-Szmek (#118)
+Changed: xxhash symbols are modified (namespace emulation) within liblz4
+
 r130:
 Fixed  : incompatibility sparse mode vs console, reported by Yongwoon Cho (#105)
 Fixed  : LZ4IO exits too early when frame crc not present, reported by Yongwoon Cho (#106)

src/lz4/README.md

@@ -1,30 +1,37 @@
 LZ4 - Extremely fast compression
 ================================
 
-LZ4 is lossless compression algorithm, 
-providing compression speed at 400 MB/s per core, 
-scalable with multi-cores CPU. 
-It also features an extremely fast decoder, 
-with speed in multiple GB/s per core, 
+LZ4 is lossless compression algorithm,
+providing compression speed at 400 MB/s per core,
+scalable with multi-cores CPU.
+It features an extremely fast decoder,
+with speed in multiple GB/s per core,
 typically reaching RAM speed limits on multi-core systems.
 
 Speed can be tuned dynamically, selecting an "acceleration" factor
 which trades compression ratio for more speed up.
 On the other end, a high compression derivative, LZ4_HC, is also provided,
 trading CPU time for improved compression ratio.
-All versions feature the same excellent decompression speed.
+All versions feature the same decompression speed.
+
+LZ4 library is provided as open-source software using BSD 2-Clause license.
 
 
 |Branch      |Status   |
 |------------|---------|
-|master      | [![Build Status](https://travis-ci.org/Cyan4973/lz4.svg?branch=master)](https://travis-ci.org/Cyan4973/lz4) [![Build status](https://ci.appveyor.com/api/projects/status/v6kxv9si529477cq/branch/master?svg=true)](https://ci.appveyor.com/project/YannCollet/lz4) |
-|dev         | [![Build Status](https://travis-ci.org/Cyan4973/lz4.svg?branch=dev)](https://travis-ci.org/Cyan4973/lz4) [![Build status](https://ci.appveyor.com/api/projects/status/v6kxv9si529477cq/branch/dev?svg=true)](https://ci.appveyor.com/project/YannCollet/lz4) |
-
-
+|master      | [![Build Status][travisMasterBadge]][travisLink] [![Build status][AppveyorMasterBadge]][AppveyorLink] [![coverity][coverBadge]][coverlink] |
+|dev         | [![Build Status][travisDevBadge]][travisLink]    [![Build status][AppveyorDevBadge]][AppveyorLink]                                         |
 
+[travisMasterBadge]: https://travis-ci.org/lz4/lz4.svg?branch=master "Continuous Integration test suite"
+[travisDevBadge]: https://travis-ci.org/lz4/lz4.svg?branch=dev "Continuous Integration test suite"
+[travisLink]: https://travis-ci.org/lz4/lz4
+[AppveyorMasterBadge]: https://ci.appveyor.com/api/projects/status/github/lz4/lz4?branch=master&svg=true "Windows test suite"
+[AppveyorDevBadge]: https://ci.appveyor.com/api/projects/status/github/lz4/lz4?branch=dev&svg=true "Windows test suite"
+[AppveyorLink]: https://ci.appveyor.com/project/YannCollet/lz4-1lndh
+[coverBadge]: https://scan.coverity.com/projects/4735/badge.svg "Static code analysis of Master branch"
+[coverlink]: https://scan.coverity.com/projects/4735
 
 > **Branch Policy:**
-
 > - The "master" branch is considered stable, at all times.
 > - The "dev" branch is the one where all contributions must be merged
     before being promoted to master.
@@ -35,24 +42,51 @@ All versions feature the same excellent decompression speed.
 Benchmarks
 -------------------------
 
-The benchmark uses the [Open-Source Benchmark program by m^2 (v0.14.3)]
-compiled with GCC v4.8.2 on Linux Mint 64-bits v17.
-The reference system uses a Core i5-4300U @1.9GHz.
+The benchmark uses [lzbench], from @inikep
+compiled with GCC v6.2.0 on Linux 64-bits.
+The reference system uses a Core i7-3930K CPU @ 4.5GHz.
 Benchmark evaluates the compression of reference [Silesia Corpus]
 in single-thread mode.
 
-|  Compressor          | Ratio   | Compression | Decompression |
-|  ----------          | -----   | ----------- | ------------- |
-|  memcpy              |  1.000  | 4200 MB/s   |   4200 MB/s   |
-|**LZ4 fast 17 (r129)**|  1.607  |**690 MB/s** | **2220 MB/s** |
-|**LZ4 default (r129)**|**2.101**|**385 MB/s** | **1850 MB/s** |
-|  LZO 2.06            |  2.108  |  350 MB/s   |    510 MB/s   |
-|  QuickLZ 1.5.1.b6    |  2.238  |  320 MB/s   |    380 MB/s   |
-|  Snappy 1.1.0        |  2.091  |  250 MB/s   |    960 MB/s   |
-|  LZF v3.6            |  2.073  |  175 MB/s   |    500 MB/s   |
-|  zlib 1.2.8 -1       |  2.730  |   59 MB/s   |    250 MB/s   |
-|**LZ4 HC (r129)**     |**2.720**|   22 MB/s   | **1830 MB/s** |
-|  zlib 1.2.8 -6       |  3.099  |   18 MB/s   |    270 MB/s   |
+[lzbench]: https://github.com/inikep/lzbench
+[Silesia Corpus]: http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
+
+|  Compressor            | Ratio   | Compression | Decompression |
+|  ----------            | -----   | ----------- | ------------- |
+|  memcpy                |  1.000  | 7300 MB/s   |   7300 MB/s   |
+|**LZ4 fast 8  (v1.7.3)**|  1.799  |**911 MB/s** | **3360 MB/s** |
+|**LZ4 default (v1.7.3)**|**2.101**|**625 MB/s** | **3220 MB/s** |
+|  LZO 2.09              |  2.108  |  620 MB/s   |    845 MB/s   |
+|  QuickLZ 1.5.0         |  2.238  |  510 MB/s   |    600 MB/s   |
+|  Snappy 1.1.3          |  2.091  |  450 MB/s   |   1550 MB/s   |
+|  LZF v3.6              |  2.073  |  365 MB/s   |    820 MB/s   |
+|  [Zstandard] 1.1.1 -1  |  2.876  |  330 MB/s   |    930 MB/s   |
+|  [Zstandard] 1.1.1 -3  |  3.164  |  200 MB/s   |    810 MB/s   |
+| [zlib] deflate 1.2.8 -1|  2.730  |  100 MB/s   |    370 MB/s   |
+|**LZ4 HC -9 (v1.7.3)**  |**2.720**|   34 MB/s   | **3240 MB/s** |
+| [zlib] deflate 1.2.8 -6|  3.099  |   33 MB/s   |    390 MB/s   |
+
+[zlib]: http://www.zlib.net/
+[Zstandard]: http://www.zstd.net/
+
+LZ4 is also compatible and well optimized for x32 mode, for which it provides an additional +10% speed performance.
+
+
+Installation
+-------------------------
+
+```
+make
+make install     # this command may require root access
+```
+
+LZ4's `Makefile` supports standard [Makefile conventions],
+including [staged installs], [redirection], or [command redefinition].
+
+[Makefile conventions]: https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html
+[staged installs]: https://www.gnu.org/prep/standards/html_node/DESTDIR.html
+[redirection]: https://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+[command redefinition]: https://www.gnu.org/prep/standards/html_node/Utilities-in-Makefiles.html
 
 
 Documentation
@@ -65,17 +99,16 @@ Organizing these blocks and providing a common header format to handle their con
 is the purpose of the Frame format, defined into [lz4_Frame_format].
 Interoperable versions of LZ4 must respect this frame format.
 
+[lz4_Block_format]: doc/lz4_Block_format.md
+[lz4_Frame_format]: doc/lz4_Frame_format.md
+
 
 Other source versions
 -------------------------
 
-Beyond the C reference source, 
-many contributors have created versions of lz4 in multiple languages.
-A list of these sources is maintained on the [LZ4 Homepage].
+Beyond the C reference source,
+many contributors have created versions of lz4 in multiple languages
+(Java, C#, Python, Perl, Ruby, etc.).
+A list of known source ports is maintained on the [LZ4 Homepage].
 
-
-[Open-Source Benchmark program by m^2 (v0.14.3)]: http://encode.ru/threads/1371-Filesystem-benchmark?p=34029&viewfull=1#post34029
-[Silesia Corpus]: http://sun.aei.polsl.pl/~sdeor/index.php?page=silesia
-[lz4_Block_format]: lz4_Block_format.md
-[lz4_Frame_format]: lz4_Frame_format.md
 [LZ4 Homepage]: http://www.lz4.org

src/lz4/appveyor.yml

@@ -0,0 +1,141 @@
+version: 1.0.{build}
+environment:
+  matrix:
+  - COMPILER: "visual"
+    CONFIGURATION: "Debug"
+    PLATFORM: "x64"
+  - COMPILER: "visual"
+    CONFIGURATION: "Debug"
+    PLATFORM: "Win32"
+  - COMPILER: "visual"
+    CONFIGURATION: "Release"
+    PLATFORM: "x64"
+  - COMPILER: "visual"
+    CONFIGURATION: "Release"
+    PLATFORM: "Win32"
+  - COMPILER: "gcc"
+    PLATFORM: "mingw64"
+  - COMPILER: "gcc"
+    PLATFORM: "mingw32"
+  - COMPILER: "gcc"
+    PLATFORM: "clang"
+
+install:
+  - ECHO Installing %COMPILER% %PLATFORM% %CONFIGURATION%
+  - MKDIR bin
+  - if [%COMPILER%]==[gcc] SET PATH_ORIGINAL=%PATH%
+  - if [%COMPILER%]==[gcc] (
+      SET "PATH_MINGW32=c:\MinGW\bin;c:\MinGW\usr\bin" &&
+      SET "PATH_MINGW64=c:\msys64\mingw64\bin;c:\msys64\usr\bin" &&
+      COPY C:\MinGW\bin\mingw32-make.exe C:\MinGW\bin\make.exe &&
+      COPY C:\MinGW\bin\gcc.exe C:\MinGW\bin\cc.exe
+    ) else (
+      IF [%PLATFORM%]==[x64] (SET ADDITIONALPARAM=/p:LibraryPath="C:\Program Files\Microsoft SDKs\Windows\v7.1\lib\x64;c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\lib\amd64;C:\Program Files (x86)\Microsoft Visual Studio 10.0\;C:\Program Files (x86)\Microsoft Visual Studio 10.0\lib\amd64;")
+    )
+
+build_script:
+  - if [%PLATFORM%]==[mingw32] SET PATH=%PATH_MINGW32%;%PATH_ORIGINAL%
+  - if [%PLATFORM%]==[mingw64] SET PATH=%PATH_MINGW64%;%PATH_ORIGINAL%
+  - if [%PLATFORM%]==[clang] SET PATH=%PATH_MINGW64%;%PATH_ORIGINAL%
+  - ECHO *** &&
+      ECHO Building %COMPILER% %PLATFORM% %CONFIGURATION% &&
+      ECHO ***
+  - if [%PLATFORM%]==[clang] (clang -v)
+  - if [%COMPILER%]==[gcc] (gcc -v)
+  - if [%COMPILER%]==[gcc] (
+      echo ----- &&
+      make -v &&
+      echo ----- &&
+      if not [%PLATFORM%]==[clang] (
+        make -C programs lz4 && make -C tests fullbench && make -C lib lib
+      ) ELSE (
+        make -C programs lz4 CC=clang MOREFLAGS="--target=x86_64-w64-mingw32 -Werror -Wconversion -Wno-sign-conversion" &&
+        make -C tests fullbench CC=clang MOREFLAGS="--target=x86_64-w64-mingw32 -Werror -Wconversion -Wno-sign-conversion" &&
+        make -C lib lib CC=clang MOREFLAGS="--target=x86_64-w64-mingw32 -Werror -Wconversion -Wno-sign-conversion"
+      )
+    )
+  - if [%COMPILER%]==[gcc] if not [%PLATFORM%]==[clang] (
+      MKDIR bin\dll bin\static bin\example bin\include &&
+      COPY tests\fullbench.c bin\example\ &&
+      COPY lib\xxhash.c bin\example\ &&
+      COPY lib\xxhash.h bin\example\ &&
+      COPY lib\lz4.h bin\include\ &&
+      COPY lib\lz4hc.h bin\include\ &&
+      COPY lib\lz4frame.h bin\include\ &&
+      COPY lib\liblz4.a bin\static\liblz4_static.lib &&
+      COPY lib\dll\liblz4.* bin\dll\ &&
+      COPY lib\dll\example\Makefile bin\example\ &&
+      COPY lib\dll\example\fullbench-dll.* bin\example\ &&
+      COPY lib\dll\example\README.md bin\ &&
+      COPY programs\lz4.exe bin\lz4.exe
+    )
+  - if [%COMPILER%]==[gcc] if [%PLATFORM%]==[mingw64] (
+      7z.exe a bin\lz4_x64.zip NEWS .\bin\lz4.exe .\bin\README.md .\bin\example .\bin\dll .\bin\static .\bin\include &&
+      appveyor PushArtifact bin\lz4_x64.zip
+    )
+  - if [%COMPILER%]==[gcc] if [%PLATFORM%]==[mingw32] (
+      7z.exe a bin\lz4_x86.zip NEWS .\bin\lz4.exe .\bin\README.md .\bin\example .\bin\dll .\bin\static .\bin\include &&
+      appveyor PushArtifact bin\lz4_x86.zip
+    )
+  - if [%COMPILER%]==[gcc] (COPY tests\fullbench.exe programs\)
+  - if [%COMPILER%]==[visual] (
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2010 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "visual\VS2010\lz4.sln" %ADDITIONALPARAM% /m /verbosity:minimal /property:PlatformToolset=v100 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2012 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "visual\VS2010\lz4.sln" /m /verbosity:minimal /property:PlatformToolset=v110 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2013 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "visual\VS2010\lz4.sln" /m /verbosity:minimal /property:PlatformToolset=v120 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      ECHO *** &&
+      ECHO *** Building Visual Studio 2015 %PLATFORM%\%CONFIGURATION% &&
+      ECHO *** &&
+      msbuild "visual\VS2010\lz4.sln" /m /verbosity:minimal /property:PlatformToolset=v140 /t:Clean,Build /p:Platform=%PLATFORM% /p:Configuration=%CONFIGURATION% /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" &&
+      COPY visual\VS2010\bin\%PLATFORM%_%CONFIGURATION%\*.exe programs\
+    )
+
+test_script:
+  - ECHO *** &&
+      ECHO Testing %COMPILER% %PLATFORM% %CONFIGURATION% &&
+      ECHO ***
+  - if not [%COMPILER%]==[unknown] (
+      CD programs &&
+      lz4 -h &&
+      lz4 -i1b lz4.exe &&
+      lz4 -i1b5 lz4.exe &&
+      lz4 -i1b10 lz4.exe &&
+      lz4 -i1b15 lz4.exe &&
+      echo ------- lz4 tested ------- &&
+      fullbench.exe -i1 fullbench.exe
+    )
+
+artifacts:
+  - path: bin\lz4_x64.zip
+  - path: bin\lz4_x86.zip
+
+deploy:
+- provider: GitHub
+  artifact: bin\lz4_x64.zip
+  auth_token:
+    secure: w6UJaGie0qbZvffr/fqyhO/Vj8rMiQWnv9a8qm3gxfngdHDTMT42wYupqJpIExId
+  force_update: true
+  prerelease: true
+  on:
+    COMPILER: gcc
+    PLATFORM: "mingw64"
+    appveyor_repo_tag: true
+
+- provider: GitHub
+  artifact: bin\lz4_x86.zip
+  auth_token:
+    secure: w6UJaGie0qbZvffr/fqyhO/Vj8rMiQWnv9a8qm3gxfngdHDTMT42wYupqJpIExId
+  force_update: true
+  prerelease: true
+  on:
+    COMPILER: gcc
+    PLATFORM: "mingw32"
+    appveyor_repo_tag: true

src/lz4/circle.yml

@@ -0,0 +1,39 @@
+dependencies:
+  override:
+    - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; sudo apt-get -y -qq update
+    - sudo apt-get -y install qemu-system-ppc qemu-user-static gcc-powerpc-linux-gnu
+    - sudo apt-get -y install qemu-system-arm gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross
+    - sudo apt-get -y install libc6-dev-i386 clang gcc-5 gcc-5-multilib gcc-6 valgrind
+
+test:
+  override:
+  # Tests compilers and C standards
+    - clang -v; make clangtest && make clean
+    - g++ -v; make gpptest     && make clean
+    - gcc -v; make c_standards && make clean
+    - gcc-5 -v; make -C tests test-lz4 CC=gcc-5 MOREFLAGS=-Werror && make clean
+    - gcc-5 -v; make -C tests test-lz4c32 CC=gcc-5 MOREFLAGS="-I/usr/include/x86_64-linux-gnu -Werror" && make clean
+    - gcc-6 -v; make c_standards CC=gcc-6 && make clean
+    - gcc-6 -v; make -C tests test-lz4 CC=gcc-6 MOREFLAGS=-Werror && make clean
+# Shorter tests
+    - make cmake               && make clean
+    - make -C tests test-lz4
+    - make -C tests test-lz4c
+    - make -C tests test-fasttest
+    - make -C tests test-frametest
+    - make -C tests test-fullbench
+    - make -C tests test-fuzzer && make clean
+    - make -C lib all && make clean
+    - pyenv global 3.4.4; CFLAGS=-I/usr/include/x86_64-linux-gnu make versionsTest && make clean
+    - make travis-install      && make clean
+  # Longer tests
+    - gcc -v; make -C tests test32 MOREFLAGS="-I/usr/include/x86_64-linux-gnu" && make clean
+    - make usan                && make clean
+    - clang -v; make staticAnalyze && make clean
+  # Valgrind tests
+    - make -C tests test-mem && make clean
+  # ARM, AArch64, PowerPC, PowerPC64 tests
+    - make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static                  && make clean
+    - make platformTest CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS=-m64 && make clean
+    - make platformTest CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static                  && make clean
+    - make platformTest CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static              && make clean

src/lz4/cmake_unofficial/CMakeLists.txt

@@ -1,90 +0,0 @@
-PROJECT(LZ4 C)
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "LZ4 compression library")
-set(CPACK_PACKAGE_VERSION_MAJOR 1)
-set(CPACK_PACKAGE_VERSION_MINOR 5)
-set(CPACK_PACKAGE_VERSION_PATCH r128)
-set(VERSION_STRING	" \"${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}\" ")
-include(CPack)
-
-cmake_minimum_required (VERSION 2.6)
-INCLUDE (CheckTypeSize)
-check_type_size("void *" SIZEOF_VOID_P)
-IF( ${SIZEOF_VOID_P} STREQUAL  "8" )
-    set (CMAKE_SYSTEM_PROCESSOR "64bit")
-    MESSAGE( STATUS "64 bit architecture detected size of void * is " ${SIZEOF_VOID_P})
-ENDIF()
-
-option(BUILD_TOOLS "Build the command line tools" ON)
-option(BUILD_LIBS  "Build the libraries in addition to the tools" ON)
-
-if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-if(UNIX AND BUILD_LIBS)
-    add_definitions(-fPIC)
-endif()
-endif()
-
-set(LZ4_DIR ../lib/)
-set(PRG_DIR ../programs/)
-set(LZ4_SRCS_LIB ${LZ4_DIR}lz4.c ${LZ4_DIR}lz4hc.c ${LZ4_DIR}lz4.h ${LZ4_DIR}lz4hc.h ${LZ4_DIR}lz4frame.c ${LZ4_DIR}lz4frame.h ${LZ4_DIR}xxhash.c)
-set(LZ4_SRCS ${LZ4_DIR}lz4frame.c ${LZ4_DIR}xxhash.c ${PRG_DIR}bench.c ${PRG_DIR}lz4cli.c ${PRG_DIR}lz4io.c)
-
-if(BUILD_TOOLS AND NOT BUILD_LIBS)
-    set(LZ4_SRCS ${LZ4_SRCS} ${LZ4_SRCS_LIB})
-endif()
-
-if(BUILD_TOOLS)
-    add_executable(lz4 ${LZ4_SRCS})
-    install(TARGETS lz4 RUNTIME DESTINATION "bin/")
-endif()
-
-if(BUILD_LIBS)    
-    add_library(liblz4 ${LZ4_SRCS_LIB})
-    
-    set_target_properties(liblz4 PROPERTIES
-    OUTPUT_NAME lz4
-    SOVERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}"
-    )
-        
-    install(TARGETS liblz4
-    LIBRARY DESTINATION lib
-    ARCHIVE DESTINATION lib
-    )
-
-    install(FILES
-    ${LZ4_DIR}/lz4.h
-    ${LZ4_DIR}/lz4hc.h
-    ${LZ4_DIR}/lz4frame.h
-    DESTINATION include
-    )
-    
-    if(BUILD_TOOLS)
-        target_link_libraries(lz4 liblz4)
-    endif()
-endif()
-
-
-#warnings
-
-if(MSVC)
-ADD_DEFINITIONS("-W4")
-endif()
-if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
-ADD_DEFINITIONS("-Wall")
-endif()
-if(CMAKE_COMPILER_IS_GNUCXX)
-ADD_DEFINITIONS("-Wextra")
-ADD_DEFINITIONS("-Wundef")
-ADD_DEFINITIONS("-Wshadow")
-ADD_DEFINITIONS("-Wcast-align")
-ADD_DEFINITIONS("-Wstrict-prototypes")
-endif(CMAKE_COMPILER_IS_GNUCXX)
-if((CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) AND
-   (NOT CMAKE_SYSTEM_NAME MATCHES "SunOS"))
-ADD_DEFINITIONS("-std=c99")
-endif()
-ADD_DEFINITIONS("-DLZ4_VERSION=\"${CPACK_PACKAGE_VERSION_PATCH}\"")
-INCLUDE_DIRECTORIES (${LZ4_DIR})
-
-
-
-

src/lz4/contrib/cmake_unofficial/.gitignore

@@ -0,0 +1,9 @@
+# cmake artefact
+
+CMakeCache.txt
+CMakeFiles
+*.cmake
+Makefile
+liblz4.pc
+lz4c
+install_manifest.txt

src/lz4/contrib/cmake_unofficial/CMakeLists.txt

@@ -0,0 +1,221 @@
+# CMake support for LZ4
+#
+# To the extent possible under law, the author(s) have dedicated all
+# copyright and related and neighboring rights to this software to
+# the public domain worldwide. This software is distributed without
+# any warranty.
+#
+# For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+#
+# LZ4's CMake support is maintained by Evan Nemerson; when filing
+# bugs please mention @nemequ to make sure I see it.
+
+set(LZ4_TOP_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../..")
+
+# Parse version information
+file(STRINGS "${LZ4_TOP_SOURCE_DIR}/lib/lz4.h" LZ4_VERSION_MAJOR REGEX "^#define LZ4_VERSION_MAJOR +([0-9]+) +.*$")
+string(REGEX REPLACE "^#define LZ4_VERSION_MAJOR +([0-9]+) +.*$" "\\1" LZ4_VERSION_MAJOR "${LZ4_VERSION_MAJOR}")
+file(STRINGS "${LZ4_TOP_SOURCE_DIR}/lib/lz4.h" LZ4_VERSION_MINOR REGEX "^#define LZ4_VERSION_MINOR +([0-9]+) +.*$")
+string(REGEX REPLACE "^#define LZ4_VERSION_MINOR +([0-9]+) +.*$" "\\1" LZ4_VERSION_MINOR "${LZ4_VERSION_MINOR}")
+file(STRINGS "${LZ4_TOP_SOURCE_DIR}/lib/lz4.h" LZ4_VERSION_RELEASE REGEX "^#define LZ4_VERSION_RELEASE +([0-9]+) +.*$")
+string(REGEX REPLACE "^#define LZ4_VERSION_RELEASE +([0-9]+) +.*$" "\\1" LZ4_VERSION_RELEASE "${LZ4_VERSION_RELEASE}")
+set(LZ4_VERSION_STRING "${LZ4_VERSION_MAJOR}.${LZ4_VERSION_MINOR}.${LZ4_VERSION_RELEASE}")
+mark_as_advanced(LZ4_VERSION_STRING LZ4_VERSION_MAJOR LZ4_VERSION_MINOR LZ4_VERSION_RELEASE)
+
+if("${CMAKE_VERSION}" VERSION_LESS "3.0")
+  project(LZ4 C)
+else()
+  cmake_policy (SET CMP0048 NEW)
+  project(LZ4
+    VERSION ${LZ4_VERSION_STRING}
+    LANGUAGES C)
+endif()
+
+cmake_minimum_required (VERSION 2.8.6)
+
+# If LZ4 is being bundled in another project, we don't want to
+# install anything.  However, we want to let people override this, so
+# we'll use the LZ4_BUNDLED_MODE variable to let them do that; just
+# set it to OFF in your project before you add_subdirectory(lz4/contrib/cmake_unofficial).
+get_directory_property(LZ4_PARENT_DIRECTORY PARENT_DIRECTORY)
+if("${LZ4_BUNDLED_MODE}" STREQUAL "")
+  # Bundled mode hasn't been set one way or the other, set the default
+  # depending on whether or not we are the top-level project.
+  if("${LZ4_PARENT_DIRECTORY}" STREQUAL "")
+    set(LZ4_BUNDLED_MODE OFF)
+  else()
+    set(LZ4_BUNDLED_MODE ON)
+  endif()
+endif()
+mark_as_advanced(LZ4_BUNDLED_MODE)
+
+# CPack
+if(NOT LZ4_BUNDLED_MODE AND NOT CPack_CMake_INCLUDED)
+  set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "LZ4 compression library")
+  set(CPACK_PACKAGE_DESCRIPTION_FILE "${LZ4_TOP_SOURCE_DIR}/README.md")
+  set(CPACK_RESOURCE_FILE_LICENSE "${LZ4_TOP_SOURCE_DIR}/LICENSE")
+  set(CPACK_PACKAGE_VERSION_MAJOR ${LZ4_VERSION_MAJOR})
+  set(CPACK_PACKAGE_VERSION_MINOR ${LZ4_VERSION_MINOR})
+  set(CPACK_PACKAGE_VERSION_PATCH ${LZ4_VERSION_RELEASE})
+  include(CPack)
+endif(NOT LZ4_BUNDLED_MODE AND NOT CPack_CMake_INCLUDED)
+
+# Allow people to choose whether to build shared or static libraries
+# via the BUILD_SHARED_LIBS option unless we are in bundled mode, in
+# which case we always use static libraries.
+include(CMakeDependentOption)
+CMAKE_DEPENDENT_OPTION(BUILD_SHARED_LIBS "Build shared libraries" ON "NOT LZ4_BUNDLED_MODE" OFF)
+CMAKE_DEPENDENT_OPTION(BUILD_STATIC_LIBS "Build static libraries" OFF "BUILD_SHARED_LIBS" ON)
+
+if(NOT BUILD_SHARED_LIBS AND NOT BUILD_STATIC_LIBS)
+  message(FATAL_ERROR "Both BUILD_SHARED_LIBS and BUILD_STATIC_LIBS have been disabled")
+endif()
+
+set(LZ4_LIB_SOURCE_DIR "${LZ4_TOP_SOURCE_DIR}/lib")
+set(LZ4_PROG_SOURCE_DIR "${LZ4_TOP_SOURCE_DIR}/programs")
+
+include_directories("${LZ4_LIB_SOURCE_DIR}")
+
+# CLI sources
+set(LZ4_SOURCES
+  "${LZ4_LIB_SOURCE_DIR}/lz4.c"
+  "${LZ4_LIB_SOURCE_DIR}/lz4hc.c"
+  "${LZ4_LIB_SOURCE_DIR}/lz4.h"
+  "${LZ4_LIB_SOURCE_DIR}/lz4hc.h"
+  "${LZ4_LIB_SOURCE_DIR}/lz4frame.c"
+  "${LZ4_LIB_SOURCE_DIR}/lz4frame.h"
+  "${LZ4_LIB_SOURCE_DIR}/xxhash.c")
+set(LZ4_CLI_SOURCES
+  "${LZ4_PROG_SOURCE_DIR}/bench.c"
+  "${LZ4_PROG_SOURCE_DIR}/lz4cli.c"
+  "${LZ4_PROG_SOURCE_DIR}/lz4io.c"
+  "${LZ4_PROG_SOURCE_DIR}/datagen.c")
+
+# Whether to use position independent code for the static library.  If
+# we're building a shared library this is ignored and PIC is always
+# used.
+option(LZ4_POSITION_INDEPENDENT_LIB "Use position independent code for static library (if applicable)" ON)
+
+# liblz4
+set(LZ4_LIBRARIES_BUILT)
+if(BUILD_SHARED_LIBS)
+  add_library(lz4_shared SHARED ${LZ4_SOURCES})
+  set_target_properties(lz4_shared PROPERTIES
+    OUTPUT_NAME lz4
+    SOVERSION "${LZ4_VERSION_MAJOR}"
+    VERSION "${LZ4_VERSION_STRING}")
+  list(APPEND LZ4_LIBRARIES_BUILT lz4_shared)
+endif()
+if(BUILD_STATIC_LIBS)
+  add_library(lz4_static STATIC ${LZ4_SOURCES})
+  set_target_properties(lz4_static PROPERTIES
+    OUTPUT_NAME lz4
+    POSITION_INDEPENDENT_CODE ${LZ4_POSITION_INDEPENDENT_LIB})
+  list(APPEND LZ4_LIBRARIES_BUILT lz4_static)
+endif()
+
+# link to shared whenever possible, to static otherwise
+if(BUILD_SHARED_LIBS)
+  set(LZ4_LINK_LIBRARY lz4_shared)
+else()
+  set(LZ4_LINK_LIBRARY lz4_static)
+endif()
+
+# lz4
+add_executable(lz4cli ${LZ4_CLI_SOURCES})
+set_target_properties(lz4cli PROPERTIES OUTPUT_NAME lz4)
+target_link_libraries(lz4cli ${LZ4_LINK_LIBRARY})
+
+# lz4c
+add_executable(lz4c ${LZ4_CLI_SOURCES})
+set_target_properties(lz4c PROPERTIES COMPILE_DEFINITIONS "ENABLE_LZ4C_LEGACY_OPTIONS")
+target_link_libraries(lz4c ${LZ4_LINK_LIBRARY})
+
+# Extra warning flags
+include (CheckCCompilerFlag)
+foreach (flag
+    # GCC-style
+    -Wall
+    -Wextra
+    -Wundef
+    -Wcast-qual
+    -Wcast-align
+    -Wshadow
+    -Wswitch-enum
+    -Wdeclaration-after-statement
+    -Wstrict-prototypes
+    -Wpointer-arith
+
+    # MSVC-style
+    /W4)
+  # Because https://gcc.gnu.org/wiki/FAQ#wnowarning
+  string(REGEX REPLACE "\\-Wno\\-(.+)" "-W\\1" flag_to_test "${flag}")
+  string(REGEX REPLACE "[^a-zA-Z0-9]+" "_" test_name "CFLAG_${flag_to_test}")
+
+  check_c_compiler_flag("${ADD_COMPILER_FLAGS_PREPEND} ${flag_to_test}" ${test_name})
+
+  if(${test_name})
+    set(CMAKE_C_FLAGS "${flag} ${CMAKE_C_FLAGS}")
+  endif()
+
+  unset(test_name)
+  unset(flag_to_test)
+endforeach (flag)
+
+if(NOT LZ4_BUNDLED_MODE)
+  include(GNUInstallDirs)
+
+  install(TARGETS lz4cli lz4c
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+  install(TARGETS ${LZ4_LIBRARIES_BUILT}
+    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
+  install(FILES
+    "${LZ4_LIB_SOURCE_DIR}/lz4.h"
+    "${LZ4_LIB_SOURCE_DIR}/lz4frame.h"
+    "${LZ4_LIB_SOURCE_DIR}/lz4hc.h"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+  install(FILES "${LZ4_PROG_SOURCE_DIR}/lz4.1"
+    DESTINATION "${CMAKE_INSTALL_MANDIR}/man1")
+  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/liblz4.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+
+  # install lz4cat and unlz4 symlinks on *nix
+  if(UNIX)
+    install(CODE "
+      foreach(f lz4cat unlz4)
+        set(dest \"\$ENV{DESTDIR}${CMAKE_INSTALL_FULL_BINDIR}/\${f}\")
+        message(STATUS \"Symlinking: \${dest} -> lz4\")
+        execute_process(
+          COMMAND \"${CMAKE_COMMAND}\" -E create_symlink lz4 \"\${dest}\")
+      endforeach()
+    ")
+
+    # create manpage aliases
+    foreach(f lz4cat unlz4)
+      file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${f}.1" ".so man1/lz4.1\n")
+      install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${f}.1"
+        DESTINATION "${CMAKE_INSTALL_MANDIR}/man1")
+    endforeach()
+  endif(UNIX)
+endif(NOT LZ4_BUNDLED_MODE)
+
+# pkg-config
+set(PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+if("${CMAKE_INSTALL_FULL_LIBDIR}" STREQUAL "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  set(LIBDIR "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
+else()
+  set(LIBDIR "${CMAKE_INSTALL_FULL_LIBDIR}")
+endif()
+
+if("${CMAKE_INSTALL_FULL_INCLUDEDIR}" STREQUAL "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}")
+  set(INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+else()
+  set(INCLUDEDIR "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
+endif()
+
+# for liblz4.pc substitution
+set(VERSION ${LZ4_VERSION_STRING})
+configure_file(${LZ4_LIB_SOURCE_DIR}/liblz4.pc.in liblz4.pc @ONLY)

src/lz4/contrib/debian/changelog

@@ -0,0 +1,10 @@
+liblz4 (1.7.2) unstable; urgency=low
+
+  * Changed : moved to versioning; package, cli and library have same version number
+  * Improved: Small decompression speed boost (+4%)
+  * Improved: Performance on ARMv6 and ARMv7
+  * Added : Debianization, by Evgeniy Polyakov
+  * Makefile: Generates object files (*.o) for faster (re)compilation on low power systems
+  * Fix : cli : crash on some invalid inputs
+
+ -- Yann Collet <Cyan4973@github.com>  Sun, 28 Jun 2015 01:00:00 +0000

src/lz4/contrib/debian/compat

@@ -0,0 +1 @@
+7

src/lz4/contrib/debian/control

@@ -0,0 +1,23 @@
+Source: liblz4
+Section: devel
+Priority: optional
+Maintainer: Evgeniy Polyakov <zbr@ioremap.net>
+Build-Depends:
+ cmake (>= 2.6),
+ debhelper (>= 7.0.50~),
+ cdbs
+Standards-Version: 3.8.0
+Homepage: http://www.lz4.org/
+Vcs-Git: git://github.com/lz4/lz4.git
+Vcs-Browser: https://github.com/lz4/lz4
+
+Package: liblz4
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: Extremely Fast Compression algorithm http://www.lz4.org
+
+Package: liblz4-dev
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: Extremely Fast Compression algorithm http://www.lz4.org
+ Development files.

src/lz4/contrib/debian/copyright

@@ -0,0 +1,9 @@
+Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: liblz4
+Upstream-Contact: Yann Collet <Cyan4973@github.com>
+Source: https://github.com/lz4/lz4
+
+Files: *
+Copyright: (C) 2011+ Yann Collet
+License: GPL-2+
+ The full text of license: https://github.com/Cyan4973/lz4/blob/master/lib/LICENSE

src/lz4/contrib/debian/dirs

@@ -0,0 +1 @@
+usr/bin

src/lz4/contrib/debian/liblz4-dev.install

@@ -0,0 +1,2 @@
+usr/include/lz4*
+usr/lib/liblz4.so

src/lz4/contrib/debian/liblz4.install

@@ -0,0 +1,2 @@
+usr/lib/liblz4.so.*
+usr/bin/*

src/lz4/contrib/debian/rules

@@ -0,0 +1,8 @@
+#!/usr/bin/make -f
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/class/cmake.mk
+
+
+DEB_CMAKE_EXTRA_FLAGS := -DCMAKE_BUILD_TYPE=RelWithDebInfo ../cmake_unofficial
+

src/lz4/contrib/djgpp/Makefile

@@ -0,0 +1,130 @@
+# Copyright (c) 2015, Louis P. Santillan <lpsantil@gmail.com>
+# All rights reserved.
+# See LICENSE for licensing details.
+DESTDIR ?= /opt/local
+
+# Pulled the code below from lib/Makefile.  Might be nicer to derive this somehow without sed
+# Version numbers
+VERSION ?= 129
+RELEASE ?= r$(VERSION)
+LIBVER_MAJOR=$(shell sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lib/lz4.h)
+LIBVER_MINOR=$(shell sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lib/lz4.h)
+LIBVER_PATCH=$(shell sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lib/lz4.h)
+LIBVER=$(LIBVER_MAJOR).$(LIBVER_MINOR).$(LIBVER_PATCH)
+
+######################################################################
+
+CROSS ?= i586-pc-msdosdjgpp
+CC = $(CROSS)-gcc
+AR = $(CROSS)-ar
+LD = $(CROSS)-gcc
+
+CFLAGS ?= -O3 -std=gnu99 -Wall -Wextra -Wundef -Wshadow -Wcast-qual -Wcast-align -Wstrict-prototypes -pedantic -DLZ4_VERSION=\"$(RELEASE)\"
+LDFLAGS ?= -s
+SRC = programs/bench.c programs/lz4io.c programs/lz4cli.c
+OBJ = $(SRC:.c=.o)
+SDEPS = $(SRC:.c=.d)
+IDIR = lib
+EDIR = .
+EXE = lz4.exe
+LNK = lz4
+LDIR = lib
+LSRC = lib/lz4.c lib/lz4hc.c lib/lz4frame.c lib/xxhash.c
+INC = $(LSRC:.c=.h)
+LOBJ = $(LSRC:.c=.o)
+LSDEPS = $(LSRC:.c=.d)
+LIB = $(LDIR)/lib$(LNK).a
+
+# Since LDFLAGS defaults to "-s", probably better to override unless
+# you have a default you would like to maintain
+ifeq ($(WITH_DEBUG), 1)
+	CFLAGS += -g
+	LDFLAGS += -g
+endif
+
+# Since LDFLAGS defaults to "-s", probably better to override unless
+# you have a default you would like to maintain
+ifeq ($(WITH_PROFILING), 1)
+	CFLAGS += -pg
+	LDFLAGS += -pg
+endif
+
+%.o: %.c $(INC) Makefile
+	$(CC) $(CFLAGS) -MMD -MP -I$(IDIR) -c $< -o $@
+
+%.exe: %.o $(LIB) Makefile
+	$(LD) $< -L$(LDIR) -l$(LNK) $(LDFLAGS) $(LIBDEP) -o $@
+
+######################################################################
+######################## DO NOT MODIFY BELOW #########################
+######################################################################
+
+.PHONY: all install uninstall showconfig gstat gpush
+
+all: $(LIB) $(EXE)
+
+$(LIB): $(LOBJ)
+	$(AR) -rcs $@ $^
+
+$(EXE): $(LOBJ) $(OBJ)
+	$(LD) $(LDFLAGS) $(LOBJ) $(OBJ) -o $(EDIR)/$@
+
+clean:
+	rm -f $(OBJ) $(EXE) $(LOBJ) $(LIB) *.tmp $(SDEPS) $(LSDEPS) $(TSDEPS)
+
+install: $(INC) $(LIB) $(EXE)
+	mkdir -p $(DESTDIR)/bin $(DESTDIR)/include $(DESTDIR)/lib
+	rm -f .footprint
+	echo $(DESTDIR)/bin/$(EXE) >> .footprint
+	cp -v $(EXE) $(DESTDIR)/bin/
+	@for T in $(LIB); \
+	do ( \
+		echo $(DESTDIR)/$$T >> .footprint; \
+		cp -v --parents $$T $(DESTDIR) \
+	); done
+	@for T in $(INC); \
+	do ( \
+		echo $(DESTDIR)/include/`basename -a $$T` >> .footprint; \
+		cp -v $$T $(DESTDIR)/include/ \
+	); done
+
+uninstall: .footprint
+	@for T in $(shell cat .footprint); do rm -v $$T; done
+
+-include $(SDEPS) $(LSDEPS)
+
+showconfig:
+	@echo "PWD="$(PWD)
+	@echo "VERSION="$(VERSION)
+	@echo "RELEASE="$(RELEASE)
+	@echo "LIBVER_MAJOR="$(LIBVER_MAJOR)
+	@echo "LIBVER_MINOR="$(LIBVER_MINOR)
+	@echo "LIBVER_PATCH="$(LIBVER_PATCH)
+	@echo "LIBVER="$(LIBVER)
+	@echo "CROSS="$(CROSS)
+	@echo "CC="$(CC)
+	@echo "AR="$(AR)
+	@echo "LD="$(LD)
+	@echo "DESTDIR="$(DESTDIR)
+	@echo "CFLAGS="$(CFLAGS)
+	@echo "LDFLAGS="$(LDFLAGS)
+	@echo "SRC="$(SRC)
+	@echo "OBJ="$(OBJ)
+	@echo "IDIR="$(IDIR)
+	@echo "INC="$(INC)
+	@echo "EDIR="$(EDIR)
+	@echo "EXE="$(EXE)
+	@echo "LDIR="$(LDIR)
+	@echo "LSRC="$(LSRC)
+	@echo "LOBJ="$(LOBJ)
+	@echo "LNK="$(LNK)
+	@echo "LIB="$(LIB)
+	@echo "SDEPS="$(SDEPS)
+	@echo "LSDEPS="$(LSDEPS)
+
+gstat:
+	git status
+
+gpush:
+	git commit
+	git push

src/lz4/contrib/djgpp/README.MD

@@ -0,0 +1,21 @@
+# lz4 for DOS/djgpp
+This file details on how to compile lz4.exe, and liblz4.a for use on DOS/djgpp using
+Andrew Wu's build-djgpp cross compilers ([GH][0], [Binaries][1]) on OSX, Linux.
+
+## Setup
+* Download a djgpp tarball [binaries][1] for your platform.  
+* Extract and install it (`tar jxvf djgpp-linux64-gcc492.tar.bz2`).  Note the path.  We'll assume `/home/user/djgpp`.
+* Add the `bin` folder to your `PATH`.  In bash, do `export PATH=/home/user/djgpp/bin:$PATH`.
+* The `Makefile` in `contrib/djgpp/` sets up `CC`, `AR`, `LD` for you.  So, `CC=i586-pc-msdosdjgpp-gcc`, `AR=i586-pc-msdosdjgpp-ar`, `LD=i586-pc-msdosdjgpp-gcc`.
+
+## Building LZ4 for DOS
+In the base dir of lz4 and with `contrib/djgpp/Makefile`, try:
+Try:
+* `make -f contrib/djgpp/Makefile`
+* `make -f contrib/djgpp/Makefile liblz4.a`
+* `make -f contrib/djgpp/Makefile lz4.exe`
+* `make -f contrib/djgpp/Makefile DESTDIR=/home/user/dos install`, however it doesn't make much sense on a \*nix.
+* You can also do `make -f contrib/djgpp/Makefile uninstall`
+
+[0]: https://github.com/andrewwutw/build-djgpp
+[1]: https://github.com/andrewwutw/build-djgpp/releases

src/lz4/contrib/gen_manual/.gitignore

@@ -0,0 +1,2 @@
+# build artefact
+gen_manual

src/lz4/contrib/gen_manual/Makefile

@@ -0,0 +1,76 @@
+# ################################################################
+# Copyright (C) Przemyslaw Skibinski 2016-present
+# All rights reserved.
+#
+# BSD license
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice, this
+#   list of conditions and the following disclaimer in the documentation and/or
+#   other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# You can contact the author at :
+#  - LZ4 source repository : https://github.com/Cyan4973/lz4
+#  - LZ4 forum froup : https://groups.google.com/forum/#!forum/lz4c
+# ################################################################
+
+
+CFLAGS ?= -O3
+CFLAGS += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow -Wstrict-aliasing=1 -Wswitch-enum -Wno-comment
+CFLAGS += $(MOREFLAGS)
+FLAGS   = $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
+
+LZ4API = ../../lib/lz4.h
+LZ4MANUAL = ../../doc/lz4_manual.html
+LZ4FAPI = ../../lib/lz4frame.h
+LZ4FMANUAL = ../../doc/lz4frame_manual.html
+LIBVER_MAJOR_SCRIPT:=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LZ4API)`
+LIBVER_MINOR_SCRIPT:=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LZ4API)`
+LIBVER_PATCH_SCRIPT:=`sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LZ4API)`
+LIBVER_SCRIPT:= $(LIBVER_MAJOR_SCRIPT).$(LIBVER_MINOR_SCRIPT).$(LIBVER_PATCH_SCRIPT)
+LZ4VER := $(shell echo $(LIBVER_SCRIPT))
+
+# Define *.exe as extension for Windows systems
+ifneq (,$(filter Windows%,$(OS)))
+EXT =.exe
+else
+EXT =
+endif
+
+
+.PHONY: default
+default: gen_manual
+
+gen_manual: gen_manual.cpp
+	$(CXX) $(FLAGS) $^ -o $@$(EXT)
+
+$(LZ4MANUAL) : gen_manual $(LZ4API)
+	echo "Update lz4 manual in /doc"
+	./gen_manual $(LZ4VER) $(LZ4API) $@
+
+$(LZ4FMANUAL) : gen_manual $(LZ4FAPI)
+	echo "Update lz4frame manual in /doc"
+	./gen_manual $(LZ4VER) $(LZ4FAPI) $@
+
+.PHONY: manuals
+manuals: gen_manual $(LZ4MANUAL) $(LZ4FMANUAL)
+
+.PHONY: clean
+clean:
+	@$(RM) gen_manual$(EXT)
+	@echo Cleaning completed

src/lz4/contrib/gen_manual/README.md

@@ -0,0 +1,31 @@
+gen_manual - a program for automatic generation of manual from source code
+==========================================================================
+
+#### Introduction
+
+This simple C++ program generates a single-page HTML manual from `lz4.h`.
+
+The format of recognized comment blocks is following:
+- comments of type `/*!` mean: this is a function declaration; switch comments with declarations
+- comments of type `/**` and `/*-` mean: this is a comment; use a `<H2>` header for the first line
+- comments of type `/*=` and `/**=` mean: use a `<H3>` header and show also all functions until first empty line
+- comments of type `/*X` where `X` is different from above-mentioned are ignored
+
+Moreover:
+- `LZ4LIB_API` is removed to improve readability
+- `typedef` are detected and included even if uncommented
+- comments of type `/**<` and `/*!<` are detected and only function declaration is highlighted (bold)
+
+
+#### Usage
+
+The program requires 3 parameters:
+```
+gen_manual [lz4_version] [input_file] [output_html]
+```
+
+To compile program and generate lz4 manual we have used:
+```
+make
+./gen_manual.exe 1.7.3 ../../lib/lz4.h lz4_manual.html
+```

src/lz4/contrib/gen_manual/gen-lz4-manual.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+LIBVER_MAJOR_SCRIPT=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ../../lib/lz4.h`
+LIBVER_MINOR_SCRIPT=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ../../lib/lz4.h`
+LIBVER_PATCH_SCRIPT=`sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ../../lib/lz4.h`
+LIBVER_SCRIPT=$LIBVER_MAJOR_SCRIPT.$LIBVER_MINOR_SCRIPT.$LIBVER_PATCH_SCRIPT
+
+echo LZ4_VERSION=$LIBVER_SCRIPT
+./gen_manual "lz4 $LIBVER_SCRIPT" ../../lib/lz4.h ./lz4_manual.html
+./gen_manual "lz4frame $LIBVER_SCRIPT" ../../lib/lz4frame.h ./lz4frame_manual.html

src/lz4/contrib/gen_manual/gen_manual.cpp

@@ -0,0 +1,247 @@
+/*
+Copyright (c) 2016-present, Przemyslaw Skibinski
+All rights reserved.
+
+BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+You can contact the author at :
+- LZ4 homepage : http://www.lz4.org
+- LZ4 source repository : https://github.com/lz4/lz4
+*/
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+using namespace std;
+
+
+/* trim string at the beginning and at the end */
+void trim(string& s, string characters)
+{
+    size_t p = s.find_first_not_of(characters);
+    s.erase(0, p);
+ 
+    p = s.find_last_not_of(characters);
+    if (string::npos != p)
+       s.erase(p+1);
+}
+
+
+/* trim C++ style comments */
+void trim_comments(string &s)
+{
+    size_t spos, epos;
+
+    spos = s.find("/*");
+    epos = s.find("*/");
+    s = s.substr(spos+3, epos-(spos+3));
+}
+
+
+/* get lines until a given terminator */
+vector<string> get_lines(vector<string>& input, int& linenum, string terminator)
+{
+    vector<string> out;
+    string line;
+    size_t epos;
+
+    while ((size_t)linenum < input.size()) {
+        line = input[linenum];
+
+        if (terminator.empty() && line.empty()) { linenum--; break; }
+        
+        epos = line.find(terminator);
+        if (!terminator.empty() && epos!=string::npos) {
+            out.push_back(line);
+            break;
+        }
+        out.push_back(line);
+        linenum++;
+    }
+    return out;
+}
+
+
+/* print line with LZ4LIB_API removed and C++ comments not bold */
+void print_line(stringstream &sout, string line)
+{
+    size_t spos, epos;
+
+    if (line.substr(0,11) == "LZ4LIB_API ") line = line.substr(11);
+    if (line.substr(0,12) == "LZ4FLIB_API ") line = line.substr(12);
+    spos = line.find("/*");
+    epos = line.find("*/");
+    if (spos!=string::npos && epos!=string::npos) {
+        sout << line.substr(0, spos);
+        sout << "</b>" << line.substr(spos) << "<b>" << endl;
+    } else {
+      //  fprintf(stderr, "lines=%s\n", line.c_str());
+        sout << line << endl;
+    }
+}
+
+
+int main(int argc, char *argv[]) {
+    char exclam;
+    int linenum, chapter = 1;
+    vector<string> input, lines, comments, chapters;
+    string line, version;
+    size_t spos, l;
+    stringstream sout;
+    ifstream istream;
+    ofstream ostream;
+
+    if (argc < 4) {
+        cout << "usage: " << argv[0] << " [lz4_version] [input_file] [output_html]" << endl;
+        return 1;
+    }
+
+    version = string(argv[1]) + " Manual";
+
+    istream.open(argv[2], ifstream::in);
+    if (!istream.is_open()) {
+        cout << "Error opening file " << argv[2] << endl;
+        return 1;
+    }
+
+    ostream.open(argv[3], ifstream::out);
+    if (!ostream.is_open()) {
+        cout << "Error opening file " << argv[3] << endl;
+        return 1;
+   }
+
+    while (getline(istream, line)) {
+        input.push_back(line);
+    }
+
+    for (linenum=0; (size_t)linenum < input.size(); linenum++) {
+        line = input[linenum];
+
+        /* typedefs are detected and included even if uncommented */
+        if (line.substr(0,7) == "typedef" && line.find("{")!=string::npos) {
+            lines = get_lines(input, linenum, "}");
+            sout << "<pre><b>";
+            for (l=0; l<lines.size(); l++) {
+                print_line(sout, lines[l]);
+            }
+            sout << "</b></pre><BR>" << endl;
+            continue;
+        }
+
+        /* comments of type /**< and /*!< are detected and only function declaration is highlighted (bold) */
+        if ((line.find("/**<")!=string::npos || line.find("/*!<")!=string::npos) && line.find("*/")!=string::npos) {
+            sout << "<pre><b>";
+            print_line(sout, line);
+            sout << "</b></pre><BR>" << endl;
+            continue;
+        }
+
+        spos = line.find("/**=");
+        if (spos==string::npos) {
+            spos = line.find("/*!");
+            if (spos==string::npos)
+                spos = line.find("/**");
+            if (spos==string::npos)
+                spos = line.find("/*-");
+            if (spos==string::npos)
+                spos = line.find("/*=");
+            if (spos==string::npos)
+                continue;
+            exclam = line[spos+2];
+        }
+        else exclam = '=';
+
+        comments = get_lines(input, linenum, "*/");
+        if (!comments.empty()) comments[0] = line.substr(spos+3);
+        if (!comments.empty()) comments[comments.size()-1] = comments[comments.size()-1].substr(0, comments[comments.size()-1].find("*/"));
+        for (l=0; l<comments.size(); l++) {
+            if (comments[l].find(" *")==0) comments[l] = comments[l].substr(2);
+            else if (comments[l].find("  *")==0) comments[l] = comments[l].substr(3);
+            trim(comments[l], "*-=");
+        }
+        while (!comments.empty() && comments[comments.size()-1].empty()) comments.pop_back(); // remove empty line at the end
+        while (!comments.empty() && comments[0].empty()) comments.erase(comments.begin()); // remove empty line at the start
+
+        /* comments of type /*! mean: this is a function declaration; switch comments with declarations */
+        if (exclam == '!') {
+            if (!comments.empty()) comments.erase(comments.begin()); /* remove first line like "LZ4_XXX() :" */
+            linenum++;
+            lines = get_lines(input, linenum, "");
+
+            sout << "<pre><b>";
+            for (l=0; l<lines.size(); l++) {
+              //  fprintf(stderr, "line[%d]=%s\n", l, lines[l].c_str());
+                print_line(sout, lines[l]);
+            }
+            sout << "</b><p>";
+            for (l=0; l<comments.size(); l++) {
+                print_line(sout, comments[l]);
+            }
+            sout << "</p></pre><BR>" << endl << endl;
+        } else if (exclam == '=') { /* comments of type /*= and /**= mean: use a <H3> header and show also all functions until first empty line */
+            trim(comments[0], " ");
+            sout << "<h3>" << comments[0] << "</h3><pre>";
+            for (l=1; l<comments.size(); l++) {
+                print_line(sout, comments[l]);
+            }
+            sout << "</pre><b><pre>";
+            lines = get_lines(input, ++linenum, "");
+            for (l=0; l<lines.size(); l++) {
+                print_line(sout, lines[l]);
+            }
+            sout << "</pre></b><BR>" << endl;
+        } else { /* comments of type /** and /*- mean: this is a comment; use a <H2> header for the first line */
+            if (comments.empty()) continue;
+
+            trim(comments[0], " ");
+            sout << "<a name=\"Chapter" << chapter << "\"></a><h2>" << comments[0] << "</h2><pre>";
+            chapters.push_back(comments[0]);
+            chapter++;
+
+            for (l=1; l<comments.size(); l++) {
+                print_line(sout, comments[l]);
+            }
+            if (comments.size() > 1)
+                sout << "<BR></pre>" << endl << endl;
+            else
+                sout << "</pre>" << endl << endl;
+        }
+    }
+
+    ostream << "<html>\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-1\">\n<title>" << version << "</title>\n</head>\n<body>" << endl;
+    ostream << "<h1>" << version << "</h1>\n";
+
+    ostream << "<hr>\n<a name=\"Contents\"></a><h2>Contents</h2>\n<ol>\n";
+    for (size_t i=0; i<chapters.size(); i++)
+        ostream << "<li><a href=\"#Chapter" << i+1 << "\">" << chapters[i].c_str() << "</a></li>\n";
+    ostream << "</ol>\n<hr>\n";
+
+    ostream << sout.str();
+    ostream << "</html>" << endl << "</body>" << endl;
+
+    return 0;
+}

src/lz4/doc/lz4_Block_format.md

@@ -19,7 +19,7 @@ not how the compressor nor decompressor actually work.
 The correctness of the decompressor should not depend
 on implementation details of the compressor, and vice versa.
 
-[LZ4 Frame format]: LZ4_Frame_format.md
+[LZ4 Frame format]: lz4_Frame_format.md
 
 
 
@@ -75,25 +75,33 @@ This is a 2 bytes value, in little endian format
 The offset represents the position of the match to be copied from.
 1 means "current position - 1 byte".
 The maximum offset value is 65535, 65536 cannot be coded.
-Note that 0 is an invalid value, not used. 
+Note that 0 is an invalid value, not used.
 
 Then we need to extract the match length.
 For this, we use the second token field, the low 4-bits.
 Value, obviously, ranges from 0 to 15.
 However here, 0 means that the copy operation will be minimal.
-The minimum length of a match, called minmatch, is 4. 
+The minimum length of a match, called minmatch, is 4.
 As a consequence, a 0 value means 4 bytes, and a value of 15 means 19+ bytes.
-Similar to literal length, on reaching the highest possible value (15), 
+Similar to literal length, on reaching the highest possible value (15),
 we output additional bytes, one at a time, with values ranging from 0 to 255.
 They are added to total to provide the final match length.
 A 255 value means there is another byte to read and add.
 There is no limit to the number of optional bytes that can be output this way.
 (This points towards a maximum achievable compression ratio of about 250).
 
-With the offset and the matchlength,
-the decoder can now proceed to copy the data from the already decoded buffer.
-On decoding the matchlength, we reach the end of the compressed sequence,
-and therefore start another one.
+Decoding the matchlength reaches the end of current sequence.
+Next byte will be the start of another sequence.
+But before moving to next sequence,
+it's time to use the decoded match position and length.
+The decoder copies matchlength bytes from match position to current position.
+
+In some cases, matchlength is larger than offset.
+Therefore, match pos + match length > current pos,
+which means that later bytes to copy are not yet decoded.
+This is called an "overlap match", and must be handled with special care.
+The most common case is an offset of 1,
+meaning the last byte is repeated matchlength times.
 
 
 Parsing restrictions
@@ -102,7 +110,7 @@ There are specific parsing rules to respect in order to remain compatible
 with assumptions made by the decoder :
 
 1. The last 5 bytes are always literals
-2. The last match must start at least 12 bytes before end of block.   
+2. The last match must start at least 12 bytes before end of block.
    Consequently, a block with less than 13 bytes cannot be compressed.
 
 These rules are in place to ensure that the decoder

src/lz4/doc/lz4_Frame_format.md

@@ -1,34 +1,34 @@
 LZ4 Frame Format Description
 ============================
 
-###Notices
+### Notices
 
 Copyright (c) 2013-2015 Yann Collet
 
-Permission is granted to copy and distribute this document 
-for any  purpose and without charge, 
-including translations into other  languages 
-and incorporation into compilations, 
-provided that the copyright notice and this notice are preserved, 
-and that any substantive changes or deletions from the original 
+Permission is granted to copy and distribute this document
+for any  purpose and without charge,
+including translations into other  languages
+and incorporation into compilations,
+provided that the copyright notice and this notice are preserved,
+and that any substantive changes or deletions from the original
 are clearly marked.
 Distribution of this document is unlimited.
 
-###Version
+### Version
 
-1.5.1 (31/03/2015)
+1.6.0 (08/08/2017)
 
 
 Introduction
 ------------
 
-The purpose of this document is to define a lossless compressed data format, 
-that is independent of CPU type, operating system, 
-file system and character set, suitable for 
-File compression, Pipe and streaming compression 
-using the [LZ4 algorithm](http://www.lz4.info).
+The purpose of this document is to define a lossless compressed data format,
+that is independent of CPU type, operating system,
+file system and character set, suitable for
+File compression, Pipe and streaming compression
+using the [LZ4 algorithm](http://www.lz4.org).
 
-The data can be produced or consumed, 
+The data can be produced or consumed,
 even for an arbitrarily long sequentially presented input data stream,
 using only an a priori bounded amount of intermediate storage,
 and hence can be used in data communications.
@@ -36,7 +36,7 @@ The format uses the LZ4 compression method,
 and optional [xxHash-32 checksum method](https://github.com/Cyan4973/xxHash),
 for detection of data corruption.
 
-The data format defined by this specification 
+The data format defined by this specification
 does not attempt to allow random access to compressed data.
 
 This specification is intended for use by implementers of software
@@ -63,7 +63,7 @@ General Structure of LZ4 Frame format
 
 | MagicNb | F. Descriptor | Block | (...) | EndMark | C. Checksum |
 |:-------:|:-------------:| ----- | ----- | ------- | ----------- |
-| 4 bytes |  3-11 bytes   |       |       | 4 bytes |   4 bytes   | 
+| 4 bytes |  3-15 bytes   |       |       | 4 bytes | 0-4 bytes   |
 
 __Magic Number__
 
@@ -72,7 +72,7 @@ Value : 0x184D2204
 
 __Frame Descriptor__
 
-3 to 11 Bytes, to be detailed in the next part.
+3 to 15 Bytes, to be detailed in the next part.
 Most important part of the spec.
 
 __Data Blocks__
@@ -88,11 +88,11 @@ The size is expressed as a 32-bits value.
 __Content Checksum__
 
 Content Checksum verify that the full content has been decoded correctly.
-The content checksum is the result 
+The content checksum is the result
 of [xxh32() hash function](https://github.com/Cyan4973/xxHash)
 digesting the original (decoded) data as input, and a seed of zero.
 Content checksum is only present when its associated flag
-is set in the frame descriptor. 
+is set in the frame descriptor.
 Content Checksum validates the result,
 that all blocks were fully transmitted in the correct order and without error,
 and also that the encoding/decoding process itself generated no distortion.
@@ -108,95 +108,99 @@ In such case, each frame has its own set of descriptor flags.
 Each frame is considered independent.
 The only relation between frames is their sequential order.
 
-The ability to decode multiple concatenated frames 
+The ability to decode multiple concatenated frames
 within a single stream or file
-is left outside of this specification. 
+is left outside of this specification.
 As an example, the reference lz4 command line utility behavior is
 to decode all concatenated frames in their sequential order.
 
- 
+
 Frame Descriptor
 ----------------
 
-| FLG     | BD      | (Content Size) | HC      |
-| ------- | ------- |:--------------:| ------- |
-| 1 byte  | 1 byte  |  0 - 8 bytes   | 1 byte  | 
+| FLG     | BD      | (Content Size) | (Dictionary ID) | HC      |
+| ------- | ------- |:--------------:|:---------------:| ------- |
+| 1 byte  | 1 byte  |  0 - 8 bytes   |   0 - 4 bytes   | 1 byte  |
 
 The descriptor uses a minimum of 3 bytes,
-and up to 11 bytes depending on optional parameters.
+and up to 15 bytes depending on optional parameters.
 
 __FLG byte__
 
-|  BitNb  |   7-6   |    5    |     4     |   3     |     2     |    1-0   |
-| ------- | ------- | ------- | --------- | ------- | --------- | -------- |
-|FieldName| Version | B.Indep | B.Checksum| C.Size  | C.Checksum|*Reserved*|
+|  BitNb  |  7-6  |   5   |    4     |  3   |    2     |    1     |   0  |
+| ------- |-------|-------|----------|------|----------|----------|------|
+|FieldName|Version|B.Indep|B.Checksum|C.Size|C.Checksum|*Reserved*|DictID|
 
 
 __BD byte__
 
-|  BitNb  |     7    |     6-5-4    |  3-2-1-0 |
-| ------- | -------- | ------------ | -------- |
-|FieldName|*Reserved*| Block MaxSize|*Reserved*|
+|  BitNb  |     7    |     6-5-4     |  3-2-1-0 |
+| ------- | -------- | ------------- | -------- |
+|FieldName|*Reserved*| Block MaxSize |*Reserved*|
 
 In the tables, bit 7 is highest bit, while bit 0 is lowest.
 
 __Version Number__
 
-2-bits field, must be set to “01”.
+2-bits field, must be set to `01`.
 Any other value cannot be decoded by this version of the specification.
 Other version numbers will use different flag layouts.
 
 __Block Independence flag__
 
-If this flag is set to “1”, blocks are independent. 
+If this flag is set to “1”, blocks are independent.
 If this flag is set to “0”, each block depends on previous ones
 (up to LZ4 window size, which is 64 KB).
 In such case, it’s necessary to decode all blocks in sequence.
 
 Block dependency improves compression ratio, especially for small blocks.
-On the other hand, it makes direct jumps or multi-threaded decoding impossible.
+On the other hand, it makes random access or multi-threaded decoding impossible.
 
 __Block checksum flag__
 
 If this flag is set, each data block will be followed by a 4-bytes checksum,
 calculated by using the xxHash-32 algorithm on the raw (compressed) data block.
-The intention is to detect data corruption (storage or transmission errors) 
+The intention is to detect data corruption (storage or transmission errors)
 immediately, before decoding.
 Block checksum usage is optional.
 
 __Content Size flag__
 
-If this flag is set, the uncompressed size of data included within the frame 
+If this flag is set, the uncompressed size of data included within the frame
 will be present as an 8 bytes unsigned little endian value, after the flags.
 Content Size usage is optional.
 
 __Content checksum flag__
 
-If this flag is set, a content checksum will be appended after the EndMark.
+If this flag is set, a 32-bits content checksum will be appended
+after the EndMark.
 
-Recommended value : “1” (content checksum is present)
+__Dictionary ID flag__
+
+If this flag is set, a 4-bytes Dict-ID field will be present,
+after the descriptor flags and the Content Size.
 
 __Block Maximum Size__
 
-This information is intended to help the decoder allocate memory.
+This information is useful to help the decoder allocate memory.
 Size here refers to the original (uncompressed) data size.
 Block Maximum Size is one value among the following table :
 
-|  0  |  1  |  2  |  3  |   4   |   5    |  6   |  7   | 
-| --- | --- | --- | --- | ----- | ------ | ---- | ---- | 
-| N/A | N/A | N/A | N/A | 64 KB | 256 KB | 1 MB | 4 MB | 
+|  0  |  1  |  2  |  3  |   4   |   5    |  6   |  7   |
+| --- | --- | --- | --- | ----- | ------ | ---- | ---- |
+| N/A | N/A | N/A | N/A | 64 KB | 256 KB | 1 MB | 4 MB |
 
-The decoder may refuse to allocate block sizes above a (system-specific) size.
+The decoder may refuse to allocate block sizes above any system-specific size.
 Unused values may be used in a future revision of the spec.
-A decoder conformant to the current version of the spec
-is only able to decode blocksizes defined in this spec.
+A decoder conformant with the current version of the spec
+is only able to decode block sizes defined in this spec.
 
 __Reserved bits__
 
 Value of reserved bits **must** be 0 (zero).
 Reserved bit might be used in a future version of the specification,
 typically enabling new optional features.
-If this happens, a decoder respecting the current version of the specification
+When this happens, a decoder respecting the current specification version
 shall not be able to decode such a frame.
 
 __Content Size__
@@ -208,12 +212,32 @@ Format is Little endian.
 This value is informational, typically for display or memory allocation.
 It can be skipped by a decoder, or used to validate content correctness.
 
+__Dictionary ID__
+
+Dict-ID is only present if the associated flag is set.
+It's an unsigned 32-bits value, stored using little-endian convention.
+A dictionary is useful to compress short input sequences.
+The compressor can take advantage of the dictionary context
+to encode the input in a more compact manner.
+It works as a kind of “known prefix” which is used by
+both the compressor and the decompressor to “warm-up” reference tables.
+
+The decompressor can use Dict-ID identifier to determine
+which dictionary must be used to correctly decode data.
+The compressor and the decompressor must use exactly the same dictionary.
+It's presumed that the 32-bits dictID uniquely identifies a dictionary.
+
+Within a single frame, a single dictionary can be defined.
+When the frame descriptor defines independent blocks,
+each block will be initialized with the same dictionary.
+If the frame descriptor defines linked blocks,
+the dictionary will only be used once, at the beginning of the frame.
+
 __Header Checksum__
 
 One-byte checksum of combined descriptor fields, including optional ones.
-The value is the second byte of xxh32() : ` (xxh32()>>8) & 0xFF `
-using zero as a seed,
-and the full Frame Descriptor as an input
+The value is the second byte of `xxh32()` : ` (xxh32()>>8) & 0xFF `
+using zero as a seed, and the full Frame Descriptor as an input
 (including optional fields when they are present).
 A wrong checksum indicates an error in the descriptor.
 Header checksum is informational and can be skipped.
@@ -224,7 +248,7 @@ Data Blocks
 
 | Block Size |  data  | (Block Checksum) |
 |:----------:| ------ |:----------------:|
-|  4 bytes   |        |   0 - 4 bytes    | 
+|  4 bytes   |        |   0 - 4 bytes    |
 
 
 __Block Size__
@@ -239,7 +263,7 @@ All other bits give the size, in bytes, of the following data block
 (the size does not include the block checksum if present).
 
 Block Size shall never be larger than Block Maximum Size.
-Such a thing could happen for incompressible source data. 
+Such a thing could happen for incompressible source data.
 In such case, such a data block shall be passed in uncompressed format.
 
 __Data__
@@ -247,7 +271,7 @@ __Data__
 Where the actual data to decode stands.
 It might be compressed or not, depending on previous field indications.
 Uncompressed size of Data can be any size, up to “block maximum size”.
-Note that data block is not necessarily full : 
+Note that data block is not necessarily full :
 an arbitrary “flush” may happen anytime. Any block can be “partially filled”.
 
 __Block checksum__
@@ -256,7 +280,7 @@ Only present if the associated flag is set.
 This is a 4-bytes checksum value, in little endian format,
 calculated by using the xxHash-32 algorithm on the raw (undecoded) data block,
 and a seed of zero.
-The intention is to detect data corruption (storage or transmission errors) 
+The intention is to detect data corruption (storage or transmission errors)
 before decoding.
 
 Block checksum is cumulative with Content checksum.
@@ -267,12 +291,12 @@ Skippable Frames
 
 | Magic Number | Frame Size | User Data |
 |:------------:|:----------:| --------- |
-|   4 bytes    |  4 bytes   |           | 
+|   4 bytes    |  4 bytes   |           |
 
 Skippable frames allow the integration of user-defined data
 into a flow of concatenated frames.
 Its design is pretty straightforward,
-with the sole objective to allow the decoder to quickly skip 
+with the sole objective to allow the decoder to quickly skip
 over user-defined data and continue decoding.
 
 For the purpose of facilitating identification,
@@ -283,14 +307,14 @@ it’s recommended to start with a zero-byte LZ4 frame
 followed by a skippable frame.
 This will make it easier for file type identifiers.
 
- 
+
 __Magic Number__
 
 4 Bytes, Little endian format.
 Value : 0x184D2A5X, which means any value from 0x184D2A50 to 0x184D2A5F.
 All 16 values are valid to identify a skippable frame.
 
-__Frame Size__ 
+__Frame Size__
 
 This is the size, in bytes, of the following User Data
 (without including the magic number nor the size field itself).
@@ -313,7 +337,7 @@ Main characteristics of the legacy format :
 - Fixed block size : 8 MB.
 - All blocks must be completely filled, except the last one.
 - All blocks are always compressed, even when compression is detrimental.
-- The last block is detected either because 
+- The last block is detected either because
   it is followed by the “EOF” (End of File) mark,
   or because it is followed by a known Frame Magic Number.
 - No checksum
@@ -347,7 +371,7 @@ wether it is a file or a stream.
 
 Alternatively, if the frame is followed by a valid Frame Magic Number,
 it is considered completed.
-It makes legacy frames compatible with frame concatenation.
+This policy makes it possible to concatenate legacy frames.
 
 Any other value will be interpreted as a block size,
 and trigger an error if it does not fit within acceptable range.
@@ -356,7 +380,9 @@ and trigger an error if it does not fit within acceptable range.
 Version changes
 ---------------
 
-1.5.1 : changed format to MarkDown compatible
+1.6.0 : restored Dictionary ID field in Frame header
+
+1.5.1 : changed document format to MarkDown
 
 1.5 : removed Dictionary ID from specification
 
@@ -382,4 +408,4 @@ Version changes
 
 0.5: added copyright notice
 
-0.4 : changed format to Google Doc compatible OpenDocument
+0.4 : changed format to Google Doc compatible OpenDocument

src/lz4/doc/lz4_manual.html

@@ -0,0 +1,325 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>1.8.0 Manual</title>
+</head>
+<body>
+<h1>1.8.0 Manual</h1>
+<hr>
+<a name="Contents"></a><h2>Contents</h2>
+<ol>
+<li><a href="#Chapter1">Introduction</a></li>
+<li><a href="#Chapter2">Version</a></li>
+<li><a href="#Chapter3">Tuning parameter</a></li>
+<li><a href="#Chapter4">Simple Functions</a></li>
+<li><a href="#Chapter5">Advanced Functions</a></li>
+<li><a href="#Chapter6">Streaming Compression Functions</a></li>
+<li><a href="#Chapter7">Streaming Decompression Functions</a></li>
+<li><a href="#Chapter8">Private definitions</a></li>
+<li><a href="#Chapter9">Obsolete Functions</a></li>
+</ol>
+<hr>
+<a name="Chapter1"></a><h2>Introduction</h2><pre>
+  LZ4 is lossless compression algorithm, providing compression speed at 400 MB/s per core,
+  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
+  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
+
+  The LZ4 compression library provides in-memory compression and decompression functions.
+  Compression can be done in:
+    - a single step (described as Simple Functions)
+    - a single step, reusing a context (described in Advanced Functions)
+    - unbounded multiple steps (described as Streaming compression)
+
+  lz4.h provides block compression functions. It gives full buffer control to user.
+  Decompressing an lz4-compressed block also requires metadata (such as compressed size).
+  Each application is free to encode such metadata in whichever way it wants.
+
+  An additional format, called LZ4 frame specification (doc/lz4_Frame_format.md),
+  take care of encoding standard metadata alongside LZ4-compressed blocks.
+  If your application requires interoperability, it's recommended to use it.
+  A library is provided to take care of it, see lz4frame.h.
+<BR></pre>
+
+<a name="Chapter2"></a><h2>Version</h2><pre></pre>
+
+<pre><b>int LZ4_versionNumber (void);  </b>/**< library version number; to be used when checking dll version */<b>
+</b></pre><BR>
+<pre><b>const char* LZ4_versionString (void);   </b>/**< library version string; to be used when checking dll version */<b>
+</b></pre><BR>
+<a name="Chapter3"></a><h2>Tuning parameter</h2><pre></pre>
+
+<pre><b>#ifndef LZ4_MEMORY_USAGE
+# define LZ4_MEMORY_USAGE 14
+#endif
+</b><p> Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+ Increasing memory usage improves compression ratio
+ Reduced memory usage can improve speed, due to cache effect
+ Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
+ 
+</p></pre><BR>
+
+<a name="Chapter4"></a><h2>Simple Functions</h2><pre></pre>
+
+<pre><b>int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
+</b><p>    Compresses 'sourceSize' bytes from buffer 'source'
+    into already allocated 'dest' buffer of size 'maxDestSize'.
+    Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
+    It also runs faster, so it's a recommended setting.
+    If the function cannot compress 'source' into a more limited 'dest' budget,
+    compression stops *immediately*, and the function result is zero.
+    As a consequence, 'dest' content is not valid.
+    This function never writes outside 'dest' buffer, nor read outside 'source' buffer.
+        sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
+        maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
+        return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
+              or 0 if compression fails 
+</p></pre><BR>
+
+<pre><b>int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
+</b><p>    compressedSize : is the precise full size of the compressed block.
+    maxDecompressedSize : is the size of destination buffer, which must be already allocated.
+    return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
+             If destination buffer is not large enough, decoding will stop and output an error code (<0).
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             This function is protected against buffer overflow exploits, including malicious data packets.
+             It never writes outside output buffer, nor reads outside input buffer.
+</p></pre><BR>
+
+<a name="Chapter5"></a><h2>Advanced Functions</h2><pre></pre>
+
+<pre><b>int LZ4_compressBound(int inputSize);
+</b><p>    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
+    This function is primarily useful for memory allocation purposes (destination buffer size).
+    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
+    Note that LZ4_compress_default() compress faster when dest buffer size is >= LZ4_compressBound(srcSize)
+        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
+        return : maximum output size in a "worst case" scenario
+              or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
+</p></pre><BR>
+
+<pre><b>int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
+</b><p>    Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
+    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
+    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
+    An acceleration value of "1" is the same as regular LZ4_compress_default()
+    Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
+</p></pre><BR>
+
+<pre><b>int LZ4_sizeofState(void);
+int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
+</b><p>    Same compression function, just using an externally allocated memory space to store compression state.
+    Use LZ4_sizeofState() to know how much memory must be allocated,
+    and allocate it on 8-bytes boundaries (using malloc() typically).
+    Then, provide it as 'void* state' to compression function.
+</p></pre><BR>
+
+<pre><b>int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
+</b><p>    Reverse the logic, by compressing as much data as possible from 'source' buffer
+    into already allocated buffer 'dest' of size 'targetDestSize'.
+    This function either compresses the entire 'source' content into 'dest' if it's large enough,
+    or fill 'dest' buffer completely with as much data as possible from 'source'.
+        *sourceSizePtr : will be modified to indicate how many bytes where read from 'source' to fill 'dest'.
+                         New value is necessarily <= old value.
+        return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
+              or 0 if compression fails
+</p></pre><BR>
+
+<pre><b>int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
+</b><p>    originalSize : is the original and therefore uncompressed size
+    return : the number of bytes read from the source buffer (in other words, the compressed size)
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             Destination buffer must be already allocated. Its size must be a minimum of 'originalSize' bytes.
+    note : This function fully respect memory boundaries for properly formed compressed data.
+           It is a bit faster than LZ4_decompress_safe().
+           However, it does not provide any protection against intentionally modified data stream (malicious input).
+           Use this function in trusted environment only (data to decode comes from a trusted source).
+</p></pre><BR>
+
+<pre><b>int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
+</b><p>    This function decompress a compressed block of size 'compressedSize' at position 'source'
+    into destination buffer 'dest' of size 'maxDecompressedSize'.
+    The function tries to stop decompressing operation as soon as 'targetOutputSize' has been reached,
+    reducing decompression time.
+    return : the number of bytes decoded in the destination buffer (necessarily <= maxDecompressedSize)
+       Note : this number can be < 'targetOutputSize' should the compressed block to decode be smaller.
+             Always control how many bytes were decoded.
+             If the source stream is detected malformed, the function will stop decoding and return a negative result.
+             This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
+</p></pre><BR>
+
+<a name="Chapter6"></a><h2>Streaming Compression Functions</h2><pre></pre>
+
+<pre><b>LZ4_stream_t* LZ4_createStream(void);
+int           LZ4_freeStream (LZ4_stream_t* streamPtr);
+</b><p>  LZ4_createStream() will allocate and initialize an `LZ4_stream_t` structure.
+  LZ4_freeStream() releases its memory.
+ 
+</p></pre><BR>
+
+<pre><b>void LZ4_resetStream (LZ4_stream_t* streamPtr);
+</b><p>  An LZ4_stream_t structure can be allocated once and re-used multiple times.
+  Use this function to init an allocated `LZ4_stream_t` structure and start a new compression.
+ 
+</p></pre><BR>
+
+<pre><b>int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
+</b><p>  Use this function to load a static dictionary into LZ4_stream.
+  Any previous data will be forgotten, only 'dictionary' will remain in memory.
+  Loading a size of 0 is allowed.
+  Return : dictionary size, in bytes (necessarily <= 64 KB)
+ 
+</p></pre><BR>
+
+<pre><b>int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+</b><p>  Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
+  Important : Previous data blocks are assumed to remain present and unmodified !
+  'dst' buffer must be already allocated.
+  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
+  If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function @return==0.
+  After an error, the stream status is invalid, it can only be reset or freed.
+ 
+</p></pre><BR>
+
+<pre><b>int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
+</b><p>  If previously compressed data block is not guaranteed to remain available at its current memory location,
+  save it into a safer place (char* safeBuffer).
+  Note : it's not necessary to call LZ4_loadDict() after LZ4_saveDict(), dictionary is immediately usable.
+  @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
+ 
+</p></pre><BR>
+
+<a name="Chapter7"></a><h2>Streaming Decompression Functions</h2><pre>  Bufferless synchronous API
+<BR></pre>
+
+<pre><b>LZ4_streamDecode_t* LZ4_createStreamDecode(void);
+int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
+</b><p>  creation / destruction of streaming decompression tracking structure 
+</p></pre><BR>
+
+<pre><b>int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
+</b><p>  Use this function to instruct where to find the dictionary.
+  Setting a size of 0 is allowed (same effect as reset).
+  @return : 1 if OK, 0 if error
+ 
+</p></pre><BR>
+
+<pre><b>int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
+int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
+</b><p>  These decoding functions allow decompression of multiple blocks in "streaming" mode.
+  Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
+  In the case of a ring buffers, decoding buffer must be either :
+  - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
+    In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
+  - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
+    maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
+    In which case, encoding and decoding buffers do not need to be synchronized,
+    and encoding ring buffer can have any size, including small ones ( < 64 KB).
+  - _At least_ 64 KB + 8 bytes + maxBlockSize.
+    In which case, encoding and decoding buffers do not need to be synchronized,
+    and encoding ring buffer can have any size, including larger than decoding buffer.
+  Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
+  and indicate where it is saved using LZ4_setStreamDecode()
+</p></pre><BR>
+
+<pre><b>int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
+int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
+</b><p>  These decoding functions work the same as
+  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
+  They are stand-alone, and don't need an LZ4_streamDecode_t structure.
+ 
+</p></pre><BR>
+
+<a name="Chapter8"></a><h2>Private definitions</h2><pre>
+ Do not use these definitions.
+ They are exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
+ Using these definitions will expose code to API and/or ABI break in future versions of the library.
+<BR></pre>
+
+<pre><b>typedef struct {
+    uint32_t hashTable[LZ4_HASH_SIZE_U32];
+    uint32_t currentOffset;
+    uint32_t initCheck;
+    const uint8_t* dictionary;
+    uint8_t* bufferStart;   </b>/* obsolete, used for slideInputBuffer */<b>
+    uint32_t dictSize;
+} LZ4_stream_t_internal;
+</b></pre><BR>
+<pre><b>typedef struct {
+    const uint8_t* externalDict;
+    size_t extDictSize;
+    const uint8_t* prefixEnd;
+    size_t prefixSize;
+} LZ4_streamDecode_t_internal;
+</b></pre><BR>
+<pre><b>typedef struct {
+    unsigned int hashTable[LZ4_HASH_SIZE_U32];
+    unsigned int currentOffset;
+    unsigned int initCheck;
+    const unsigned char* dictionary;
+    unsigned char* bufferStart;   </b>/* obsolete, used for slideInputBuffer */<b>
+    unsigned int dictSize;
+} LZ4_stream_t_internal;
+</b></pre><BR>
+<pre><b>typedef struct {
+    const unsigned char* externalDict;
+    size_t extDictSize;
+    const unsigned char* prefixEnd;
+    size_t prefixSize;
+} LZ4_streamDecode_t_internal;
+</b></pre><BR>
+<pre><b>#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
+#define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
+union LZ4_stream_u {
+    unsigned long long table[LZ4_STREAMSIZE_U64];
+    LZ4_stream_t_internal internal_donotuse;
+} ;  </b>/* previously typedef'd to LZ4_stream_t */<b>
+</b><p> information structure to track an LZ4 stream.
+ init this structure before first use.
+ note : only use in association with static linking !
+        this definition is not API/ABI safe,
+        it may change in a future version !
+ 
+</p></pre><BR>
+
+<pre><b>#define LZ4_STREAMDECODESIZE_U64  4
+#define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
+union LZ4_streamDecode_u {
+    unsigned long long table[LZ4_STREAMDECODESIZE_U64];
+    LZ4_streamDecode_t_internal internal_donotuse;
+} ;   </b>/* previously typedef'd to LZ4_streamDecode_t */<b>
+</b><p> information structure to track an LZ4 stream during decompression.
+ init this structure  using LZ4_setStreamDecode (or memset()) before first use
+ note : only use in association with static linking !
+        this definition is not API/ABI safe,
+        and may change in a future version !
+ 
+</p></pre><BR>
+
+<a name="Chapter9"></a><h2>Obsolete Functions</h2><pre></pre>
+
+<pre><b>#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
+#  define LZ4_DEPRECATED(message)   </b>/* disable deprecation warnings */<b>
+#else
+#  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#  if defined (__cplusplus) && (__cplusplus >= 201402) </b>/* C++14 or greater */<b>
+#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
+#  elif (LZ4_GCC_VERSION >= 405) || defined(__clang__)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
+#  elif (LZ4_GCC_VERSION >= 301)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
+#  elif defined(_MSC_VER)
+#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
+#  else
+#    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
+#    define LZ4_DEPRECATED(message)
+#  endif
+#endif </b>/* LZ4_DISABLE_DEPRECATE_WARNINGS */<b>
+</b><p>   Should deprecation warnings be a problem,
+   it is generally possible to disable them,
+   typically with -Wno-deprecated-declarations for gcc
+   or _CRT_SECURE_NO_WARNINGS in Visual.
+   Otherwise, it's also possible to define LZ4_DISABLE_DEPRECATE_WARNINGS 
+</p></pre><BR>
+
+</html>
+</body>

src/lz4/doc/lz4frame_manual.html

@@ -0,0 +1,277 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>1.8.0 Manual</title>
+</head>
+<body>
+<h1>1.8.0 Manual</h1>
+<hr>
+<a name="Contents"></a><h2>Contents</h2>
+<ol>
+<li><a href="#Chapter1">Introduction</a></li>
+<li><a href="#Chapter2">Compiler specifics</a></li>
+<li><a href="#Chapter3">Error management</a></li>
+<li><a href="#Chapter4">Frame compression types</a></li>
+<li><a href="#Chapter5">Simple compression function</a></li>
+<li><a href="#Chapter6">Advanced compression functions</a></li>
+<li><a href="#Chapter7">Resource Management</a></li>
+<li><a href="#Chapter8">Compression</a></li>
+<li><a href="#Chapter9">Decompression functions</a></li>
+<li><a href="#Chapter10">Streaming decompression functions</a></li>
+</ol>
+<hr>
+<a name="Chapter1"></a><h2>Introduction</h2><pre>
+  lz4frame.h implements LZ4 frame specification (doc/lz4_Frame_format.md).
+  lz4frame.h provides frame compression functions that take care
+  of encoding standard metadata alongside LZ4-compressed blocks.
+<BR></pre>
+
+<a name="Chapter2"></a><h2>Compiler specifics</h2><pre></pre>
+
+<a name="Chapter3"></a><h2>Error management</h2><pre></pre>
+
+<pre><b>unsigned    LZ4F_isError(LZ4F_errorCode_t code);   </b>/**< tells if a `LZ4F_errorCode_t` function result is an error code */<b>
+</b></pre><BR>
+<pre><b>const char* LZ4F_getErrorName(LZ4F_errorCode_t code);   </b>/**< return error code string; useful for debugging */<b>
+</b></pre><BR>
+<a name="Chapter4"></a><h2>Frame compression types</h2><pre></pre>
+
+<pre><b>typedef enum {
+    LZ4F_default=0,
+    LZ4F_max64KB=4,
+    LZ4F_max256KB=5,
+    LZ4F_max1MB=6,
+    LZ4F_max4MB=7
+    LZ4F_OBSOLETE_ENUM(max64KB)
+    LZ4F_OBSOLETE_ENUM(max256KB)
+    LZ4F_OBSOLETE_ENUM(max1MB)
+    LZ4F_OBSOLETE_ENUM(max4MB)
+} LZ4F_blockSizeID_t;
+</b></pre><BR>
+<pre><b>typedef enum {
+    LZ4F_blockLinked=0,
+    LZ4F_blockIndependent
+    LZ4F_OBSOLETE_ENUM(blockLinked)
+    LZ4F_OBSOLETE_ENUM(blockIndependent)
+} LZ4F_blockMode_t;
+</b></pre><BR>
+<pre><b>typedef enum {
+    LZ4F_noContentChecksum=0,
+    LZ4F_contentChecksumEnabled
+    LZ4F_OBSOLETE_ENUM(noContentChecksum)
+    LZ4F_OBSOLETE_ENUM(contentChecksumEnabled)
+} LZ4F_contentChecksum_t;
+</b></pre><BR>
+<pre><b>typedef enum {
+    LZ4F_noBlockChecksum=0,
+    LZ4F_blockChecksumEnabled
+} LZ4F_blockChecksum_t;
+</b></pre><BR>
+<pre><b>typedef enum {
+    LZ4F_frame=0,
+    LZ4F_skippableFrame
+    LZ4F_OBSOLETE_ENUM(skippableFrame)
+} LZ4F_frameType_t;
+</b></pre><BR>
+<pre><b>typedef struct {
+  LZ4F_blockSizeID_t     blockSizeID;          </b>/* max64KB, max256KB, max1MB, max4MB ; 0 == default */<b>
+  LZ4F_blockMode_t       blockMode;            </b>/* LZ4F_blockLinked, LZ4F_blockIndependent ; 0 == default */<b>
+  LZ4F_contentChecksum_t contentChecksumFlag;  </b>/* if enabled, frame is terminated with a 32-bits checksum of decompressed data ; 0 == disabled (default)  */<b>
+  LZ4F_frameType_t       frameType;            </b>/* read-only field : LZ4F_frame or LZ4F_skippableFrame */<b>
+  unsigned long long     contentSize;          </b>/* Size of uncompressed content ; 0 == unknown */<b>
+  unsigned               dictID;               </b>/* Dictionary ID, sent by the compressor to help decoder select the correct dictionary; 0 == no dictID provided */<b>
+  LZ4F_blockChecksum_t   blockChecksumFlag;    </b>/* if enabled, each block is followed by a checksum of block's compressed data ; 0 == disabled (default)  */<b>
+} LZ4F_frameInfo_t;
+</b><p>  makes it possible to set or read frame parameters.
+  It's not required to set all fields, as long as the structure was initially memset() to zero.
+  For all fields, 0 sets it to default value 
+</p></pre><BR>
+
+<pre><b>typedef struct {
+  LZ4F_frameInfo_t frameInfo;
+  int      compressionLevel;       </b>/* 0 == default (fast mode); values above LZ4HC_CLEVEL_MAX count as LZ4HC_CLEVEL_MAX; values below 0 trigger "fast acceleration", proportional to value */<b>
+  unsigned autoFlush;              </b>/* 1 == always flush, to reduce usage of internal buffers */<b>
+  unsigned reserved[4];            </b>/* must be zero for forward compatibility */<b>
+} LZ4F_preferences_t;
+</b><p>  makes it possible to supply detailed compression parameters to the stream interface.
+  It's not required to set all fields, as long as the structure was initially memset() to zero.
+  All reserved fields must be set to zero. 
+</p></pre><BR>
+
+<a name="Chapter5"></a><h2>Simple compression function</h2><pre></pre>
+
+<pre><b>size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr);
+</b><p>  Returns the maximum possible size of a frame compressed with LZ4F_compressFrame() given srcSize content and preferences.
+  Note : this result is only usable with LZ4F_compressFrame(), not with multi-segments compression.
+ 
+</p></pre><BR>
+
+<pre><b>size_t LZ4F_compressFrame(void* dstBuffer, size_t dstCapacity,
+                                const void* srcBuffer, size_t srcSize,
+                                const LZ4F_preferences_t* preferencesPtr);
+</b><p>  Compress an entire srcBuffer into a valid LZ4 frame.
+  dstCapacity MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
+  The LZ4F_preferences_t structure is optional : you can provide NULL as argument. All preferences will be set to default.
+ @return : number of bytes written into dstBuffer.
+           or an error code if it fails (can be tested using LZ4F_isError())
+ 
+</p></pre><BR>
+
+<a name="Chapter6"></a><h2>Advanced compression functions</h2><pre></pre>
+
+<pre><b>typedef struct {
+  unsigned stableSrc;    </b>/* 1 == src content will remain present on future calls to LZ4F_compress(); skip copying src content within tmp buffer */<b>
+  unsigned reserved[3];
+} LZ4F_compressOptions_t;
+</b></pre><BR>
+<a name="Chapter7"></a><h2>Resource Management</h2><pre></pre>
+
+<pre><b>LZ4F_errorCode_t LZ4F_createCompressionContext(LZ4F_cctx** cctxPtr, unsigned version);
+LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctx);
+</b><p> The first thing to do is to create a compressionContext object, which will be used in all compression operations.
+ This is achieved using LZ4F_createCompressionContext(), which takes as argument a version.
+ The version provided MUST be LZ4F_VERSION. It is intended to track potential version mismatch, notably when using DLL.
+ The function will provide a pointer to a fully allocated LZ4F_cctx object.
+ If @return != zero, there was an error during context creation.
+ Object can release its memory using LZ4F_freeCompressionContext();
+ 
+</p></pre><BR>
+
+<a name="Chapter8"></a><h2>Compression</h2><pre></pre>
+
+<pre><b>size_t LZ4F_compressBegin(LZ4F_cctx* cctx,
+                                      void* dstBuffer, size_t dstCapacity,
+                                      const LZ4F_preferences_t* prefsPtr);
+</b><p>  will write the frame header into dstBuffer.
+  dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes.
+ `prefsPtr` is optional : you can provide NULL as argument, all preferences will then be set to default.
+ @return : number of bytes written into dstBuffer for the header
+           or an error code (which can be tested using LZ4F_isError())
+ 
+</p></pre><BR>
+
+<pre><b>size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* prefsPtr);
+</b><p> Provides dstCapacity given a srcSize to guarantee operation success in worst case situations.
+ prefsPtr is optional : you can provide NULL as argument, preferences will be set to cover worst case scenario.
+ Result is always the same for a srcSize and prefsPtr, so it can be trusted to size reusable buffers.
+ When srcSize==0, LZ4F_compressBound() provides an upper bound for LZ4F_flush() and LZ4F_compressEnd() operations.
+ 
+</p></pre><BR>
+
+<pre><b>size_t LZ4F_compressUpdate(LZ4F_cctx* cctx, void* dstBuffer, size_t dstCapacity, const void* srcBuffer, size_t srcSize, const LZ4F_compressOptions_t* cOptPtr);
+</b><p> LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary.
+ An important rule is that dstCapacity MUST be large enough to ensure operation success even in worst case situations.
+ This value is provided by LZ4F_compressBound().
+ If this condition is not respected, LZ4F_compress() will fail (result is an errorCode).
+ LZ4F_compressUpdate() doesn't guarantee error recovery. When an error occurs, compression context must be freed or resized.
+ `cOptPtr` is optional : NULL can be provided, in which case all options are set to default.
+ @return : number of bytes written into `dstBuffer` (it can be zero, meaning input data was just buffered).
+           or an error code if it fails (which can be tested using LZ4F_isError())
+ 
+</p></pre><BR>
+
+<pre><b>size_t LZ4F_flush(LZ4F_cctx* cctx, void* dstBuffer, size_t dstCapacity, const LZ4F_compressOptions_t* cOptPtr);
+</b><p> When data must be generated and sent immediately, without waiting for a block to be completely filled,
+ it's possible to call LZ4_flush(). It will immediately compress any data buffered within cctx.
+ `dstCapacity` must be large enough to ensure the operation will be successful.
+ `cOptPtr` is optional : it's possible to provide NULL, all options will be set to default.
+ @return : number of bytes written into dstBuffer (it can be zero, which means there was no data stored within cctx)
+           or an error code if it fails (which can be tested using LZ4F_isError())
+ 
+</p></pre><BR>
+
+<pre><b>size_t LZ4F_compressEnd(LZ4F_cctx* cctx, void* dstBuffer, size_t dstCapacity, const LZ4F_compressOptions_t* cOptPtr);
+</b><p>  To properly finish an LZ4 frame, invoke LZ4F_compressEnd().
+  It will flush whatever data remained within `cctx` (like LZ4_flush())
+  and properly finalize the frame, with an endMark and a checksum.
+ `cOptPtr` is optional : NULL can be provided, in which case all options will be set to default.
+ @return : number of bytes written into dstBuffer (necessarily >= 4 (endMark), or 8 if optional frame checksum is enabled)
+           or an error code if it fails (which can be tested using LZ4F_isError())
+  A successful call to LZ4F_compressEnd() makes `cctx` available again for another compression task.
+ 
+</p></pre><BR>
+
+<a name="Chapter9"></a><h2>Decompression functions</h2><pre></pre>
+
+<pre><b>typedef struct {
+  unsigned stableDst;    </b>/* pledge that at least 64KB+64Bytes of previously decompressed data remain unmodifed where it was decoded. This optimization skips storage operations in tmp buffers */<b>
+  unsigned reserved[3];  </b>/* must be set to zero for forward compatibility */<b>
+} LZ4F_decompressOptions_t;
+</b></pre><BR>
+<pre><b>LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_dctx** dctxPtr, unsigned version);
+LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx);
+</b><p> Create an LZ4F_dctx object, to track all decompression operations.
+ The version provided MUST be LZ4F_VERSION.
+ The function provides a pointer to an allocated and initialized LZ4F_dctx object.
+ The result is an errorCode, which can be tested using LZ4F_isError().
+ dctx memory can be released using LZ4F_freeDecompressionContext();
+ The result of LZ4F_freeDecompressionContext() is indicative of the current state of decompressionContext when being released.
+ That is, it should be == 0 if decompression has been completed fully and correctly.
+ 
+</p></pre><BR>
+
+<a name="Chapter10"></a><h2>Streaming decompression functions</h2><pre></pre>
+
+<pre><b>size_t LZ4F_getFrameInfo(LZ4F_dctx* dctx,
+                                     LZ4F_frameInfo_t* frameInfoPtr,
+                                     const void* srcBuffer, size_t* srcSizePtr);
+</b><p>  This function extracts frame parameters (max blockSize, dictID, etc.).
+  Its usage is optional.
+  Extracted information is typically useful for allocation and dictionary.
+  This function works in 2 situations :
+   - At the beginning of a new frame, in which case
+     it will decode information from `srcBuffer`, starting the decoding process.
+     Input size must be large enough to successfully decode the entire frame header.
+     Frame header size is variable, but is guaranteed to be <= LZ4F_HEADER_SIZE_MAX bytes.
+     It's allowed to provide more input data than this minimum.
+   - After decoding has been started.
+     In which case, no input is read, frame parameters are extracted from dctx.
+   - If decoding has barely started, but not yet extracted information from header,
+     LZ4F_getFrameInfo() will fail.
+  The number of bytes consumed from srcBuffer will be updated within *srcSizePtr (necessarily <= original value).
+  Decompression must resume from (srcBuffer + *srcSizePtr).
+ @return : an hint about how many srcSize bytes LZ4F_decompress() expects for next call,
+           or an error code which can be tested using LZ4F_isError().
+  note 1 : in case of error, dctx is not modified. Decoding operation can resume from beginning safely.
+  note 2 : frame parameters are *copied into* an already allocated LZ4F_frameInfo_t structure.
+ 
+</p></pre><BR>
+
+<pre><b>size_t LZ4F_decompress(LZ4F_dctx* dctx,
+                                   void* dstBuffer, size_t* dstSizePtr,
+                                   const void* srcBuffer, size_t* srcSizePtr,
+                                   const LZ4F_decompressOptions_t* dOptPtr);
+</b><p>  Call this function repetitively to regenerate compressed data from `srcBuffer`.
+  The function will attempt to decode up to *srcSizePtr bytes from srcBuffer, into dstBuffer of capacity *dstSizePtr.
+
+  The number of bytes regenerated into dstBuffer is provided within *dstSizePtr (necessarily <= original value).
+
+  The number of bytes consumed from srcBuffer is provided within *srcSizePtr (necessarily <= original value).
+  Number of bytes consumed can be < number of bytes provided.
+  It typically happens when dstBuffer is not large enough to contain all decoded data.
+  Unconsumed source data must be presented again in subsequent invocations.
+
+ `dstBuffer` content is expected to be flushed between each invocation, as its content will be overwritten.
+ `dstBuffer` itself can be changed at will between each consecutive function invocation.
+
+ @return : an hint of how many `srcSize` bytes LZ4F_decompress() expects for next call.
+  Schematically, it's the size of the current (or remaining) compressed block + header of next block.
+  Respecting the hint provides some small speed benefit, because it skips intermediate buffers.
+  This is just a hint though, it's always possible to provide any srcSize.
+  When a frame is fully decoded, @return will be 0 (no more data expected).
+  If decompression failed, @return is an error code, which can be tested using LZ4F_isError().
+
+  After a frame is fully decoded, dctx can be used again to decompress another frame.
+  After a decompression error, use LZ4F_resetDecompressionContext() before re-using dctx, to return to clean state.
+ 
+</p></pre><BR>
+
+<pre><b>void LZ4F_resetDecompressionContext(LZ4F_dctx* dctx);   </b>/* always successful */<b>
+</b><p>  In case of an error, the context is left in "undefined" state.
+  In which case, it's necessary to reset it, before re-using it.
+  This method can also be used to abruptly stop an unfinished decompression,
+  and start a new one using the same context. 
+</p></pre><BR>
+
+</html>
+</body>

src/lz4/examples/.gitignore

@@ -0,0 +1,10 @@
+/Makefile.lz4*
+/printVersion
+/doubleBuffer
+/dictionaryRandomAccess
+/ringBuffer
+/ringBufferHC
+/lineCompress
+/frameCompress
+/simpleBuffer
+/*.exe

src/lz4/examples/COPYING

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

src/lz4/examples/HCStreaming_ringBuffer.c

@@ -6,7 +6,7 @@
  * Compiler Options
  **************************************/
 #ifdef _MSC_VER    /* Visual Studio */
-#  define _CRT_SECURE_NO_WARNINGS // for MSVC
+#  define _CRT_SECURE_NO_WARNINGS   /* for MSVC */
 #  define snprintf sprintf_s
 #endif
 
@@ -59,17 +59,16 @@ void test_compress(FILE* outFp, FILE* inpFp)
     static char inpBuf[RING_BUFFER_BYTES];
     int inpOffset = 0;
 
-    for(;;)
-    {
+    for(;;) {
         // Read random length ([1,MESSAGE_MAX_BYTES]) data to the ring buffer.
         char* const inpPtr = &inpBuf[inpOffset];
         const int randomLength = (rand() % MESSAGE_MAX_BYTES) + 1;
         const int inpBytes = (int) read_bin(inpFp, inpPtr, randomLength);
         if (0 == inpBytes) break;
 
-        {
-            char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)];
-            const int cmpBytes = LZ4_compressHC_continue(lz4Stream, inpPtr, cmpBuf, inpBytes);
+#define CMPBUFSIZE (LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES))
+        {   char cmpBuf[CMPBUFSIZE];
+            const int cmpBytes = LZ4_compress_HC_continue(lz4Stream, inpPtr, cmpBuf, inpBytes, CMPBUFSIZE);
 
             if(cmpBytes <= 0) break;
             write_int32(outFp, cmpBytes);
@@ -94,13 +93,11 @@ void test_decompress(FILE* outFp, FILE* inpFp)
     LZ4_streamDecode_t lz4StreamDecode_body = { 0 };
     LZ4_streamDecode_t* lz4StreamDecode = &lz4StreamDecode_body;
 
-    for(;;)
-    {
+    for(;;) {
         int  cmpBytes = 0;
-        char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)];
+        char cmpBuf[CMPBUFSIZE];
 
-        {
-            const size_t r0 = read_int32(inpFp, &cmpBytes);
+        {   const size_t r0 = read_int32(inpFp, &cmpBytes);
             size_t r1;
             if(r0 != 1 || cmpBytes <= 0)
                 break;
@@ -110,8 +107,7 @@ void test_decompress(FILE* outFp, FILE* inpFp)
                 break;
         }
 
-        {
-            char* const decPtr = &decBuf[decOffset];
+        {   char* const decPtr = &decBuf[decOffset];
             const int decBytes = LZ4_decompress_safe_continue(
                 lz4StreamDecode, cmpBuf, decPtr, cmpBytes, MESSAGE_MAX_BYTES);
             if(decBytes <= 0)
@@ -135,8 +131,7 @@ size_t compare(FILE* f0, FILE* f1)
 {
     size_t result = 1;
 
-    for (;;)
-    {
+    for (;;) {
         char b0[65536];
         char b1[65536];
         const size_t r0 = fread(b0, 1, sizeof(b0), f0);
@@ -144,16 +139,14 @@ size_t compare(FILE* f0, FILE* f1)
 
         if ((r0==0) && (r1==0)) return 0;   // success
 
-        if (r0 != r1)
-        {
+        if (r0 != r1) {
             size_t smallest = r0;
             if (r1<r0) smallest = r1;
             result += smallest;
             break;
         }
 
-        if (memcmp(b0, b1, r0))
-        {
+        if (memcmp(b0, b1, r0)) {
             unsigned errorPos = 0;
             while ((errorPos < r0) && (b0[errorPos]==b1[errorPos])) errorPos++;
             result += errorPos;
@@ -167,7 +160,7 @@ size_t compare(FILE* f0, FILE* f1)
 }
 
 
-int main(int argc, char** argv)
+int main(int argc, const char** argv)
 {
     char inpFilename[256] = { 0 };
     char lz4Filename[256] = { 0 };
@@ -192,9 +185,8 @@ int main(int argc, char** argv)
     printf("decoded = [%s]\n", decFilename);
 
     // compress
-    {
-        FILE* inpFp = fopen(inpFilename, "rb");
-        FILE* outFp = fopen(lz4Filename, "wb");
+    {   FILE* const inpFp = fopen(inpFilename, "rb");
+        FILE* const outFp = fopen(lz4Filename, "wb");
 
         test_compress(outFp, inpFp);
 
@@ -203,9 +195,8 @@ int main(int argc, char** argv)
     }
 
     // decompress
-    {
-        FILE* inpFp = fopen(lz4Filename, "rb");
-        FILE* outFp = fopen(decFilename, "wb");
+    {   FILE* const inpFp = fopen(lz4Filename, "rb");
+        FILE* const outFp = fopen(decFilename, "wb");
 
         test_decompress(outFp, inpFp);
 
@@ -214,9 +205,8 @@ int main(int argc, char** argv)
     }
 
     // verify
-    {
-        FILE* inpFp = fopen(inpFilename, "rb");
-        FILE* decFp = fopen(decFilename, "rb");
+    {   FILE* const inpFp = fopen(inpFilename, "rb");
+        FILE* const decFp = fopen(decFilename, "rb");
 
         const size_t cmp = compare(inpFp, decFp);
         if(0 == cmp) {
@@ -229,10 +219,10 @@ int main(int argc, char** argv)
         fclose(inpFp);
     }
 
-    if (pause)
-    {
+    if (pause) {
+        int unused;
         printf("Press enter to continue ...\n");
-        getchar();
+        unused = getchar(); (void)unused;   /* silence static analyzer */
     }
 
     return 0;

src/lz4/examples/Makefile

@@ -19,7 +19,7 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 # You can contact the author at :
-#  - LZ4 source repository : http://code.google.com/p/lz4/
+#  - LZ4 source repository : https://github.com/Cyan4973/lz4
 #  - LZ4 forum froup : https://groups.google.com/forum/#!forum/lz4c
 # ##########################################################################
 # This makefile compile and test
@@ -27,12 +27,14 @@
 # kindly provided by Takayuki Matsuoka
 # ##########################################################################
 
-CFLAGS ?= -O3
-CFLAGS += -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes
-FLAGS  := -I../lib $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
+CPPFLAGS += -I../lib
+CFLAGS   ?= -O3
+CFLAGS   += -std=gnu99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes
+FLAGS    := $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
 
 TESTFILE= Makefile
 LZ4DIR := ../lib
+LZ4 = ../programs/lz4
 
 
 # Define *.exe as extension for Windows systems
@@ -47,7 +49,8 @@ endif
 
 default: all
 
-all: printVersion doubleBuffer ringBuffer ringBufferHC lineCompress
+all: printVersion doubleBuffer dictionaryRandomAccess ringBuffer ringBufferHC \
+     lineCompress frameCompress simpleBuffer
 
 printVersion: $(LZ4DIR)/lz4.c printVersion.c
 	$(CC)      $(FLAGS) $^ -o $@$(EXT)
@@ -55,6 +58,9 @@ printVersion: $(LZ4DIR)/lz4.c printVersion.c
 doubleBuffer: $(LZ4DIR)/lz4.c blockStreaming_doubleBuffer.c
 	$(CC)      $(FLAGS) $^ -o $@$(EXT)
 
+dictionaryRandomAccess: $(LZ4DIR)/lz4.c dictionaryRandomAccess.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+
 ringBuffer  : $(LZ4DIR)/lz4.c blockStreaming_ringBuffer.c
 	$(CC)      $(FLAGS) $^ -o $@$(EXT)
 
@@ -64,15 +70,29 @@ ringBufferHC: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c HCStreaming_ringBuffer.c
 lineCompress: $(LZ4DIR)/lz4.c blockStreaming_lineByLine.c
 	$(CC)      $(FLAGS) $^ -o $@$(EXT)
 
+frameCompress: frameCompress.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT) $(LZ4DIR)/liblz4.a
+
+compressFunctions: $(LZ4DIR)/lz4.c compress_functions.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT) -lrt
+
+simpleBuffer: $(LZ4DIR)/lz4.c simple_buffer.c
+	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+
 test : all
 	./printVersion$(EXT)
 	./doubleBuffer$(EXT) $(TESTFILE)
+	./dictionaryRandomAccess$(EXT) $(TESTFILE) $(TESTFILE) 1100 1400
 	./ringBuffer$(EXT)   $(TESTFILE)
 	./ringBufferHC$(EXT) $(TESTFILE)
 	./lineCompress$(EXT) $(TESTFILE)
+	./frameCompress$(EXT) $(TESTFILE)
+	./simpleBuffer$(EXT)
+	$(LZ4) -vt $(TESTFILE).lz4
 
 clean:
-	@rm -f core *.o *.dec *-0 *-9 *-8192 *.lz4s \
-        printVersion$(EXT) doubleBuffer$(EXT) ringBuffer$(EXT) ringBufferHC$(EXT) lineCompress$(EXT)
+	@rm -f core *.o *.dec *-0 *-9 *-8192 *.lz4s *.lz4 \
+	 printVersion$(EXT) doubleBuffer$(EXT) dictionaryRandomAccess$(EXT) \
+	 ringBuffer$(EXT) ringBufferHC$(EXT) lineCompress$(EXT) frameCompress$(EXT) \
+	 compressFunctions$(EXT) simpleBuffer$(EXT)
 	@echo Cleaning completed
-

src/lz4/examples/README.md

@@ -1,8 +1,11 @@
 # LZ4 examples
 
+All examples are GPL-v2 licensed.
+
 ## Documents
 
  - [Streaming API Basics](streaming_api_basics.md)
  - Examples
      - [Double Buffer](blockStreaming_doubleBuffer.md)
      - [Line by Line Text Compression](blockStreaming_lineByLine.md)
+     - [Dictionary Random Access](dictionaryRandomAccess.md)

src/lz4/examples/blockStreaming_doubleBuffer.c

@@ -43,7 +43,7 @@ void test_compress(FILE* outFp, FILE* inpFp)
 
     char inpBuf[2][BLOCK_BYTES];
     int  inpBufIndex = 0;
-    
+
     LZ4_resetStream(lz4Stream);
 
     for(;;) {

src/lz4/examples/blockStreaming_ringBuffer.c

@@ -64,8 +64,9 @@ void test_compress(FILE* outFp, FILE* inpFp)
         if (0 == inpBytes) break;
 
         {
-            char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)];
-            const int cmpBytes = LZ4_compress_continue(lz4Stream, inpPtr, cmpBuf, inpBytes);
+#define CMPBUFSIZE (LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES))
+            char cmpBuf[CMPBUFSIZE];
+            const int cmpBytes = LZ4_compress_fast_continue(lz4Stream, inpPtr, cmpBuf, inpBytes, CMPBUFSIZE, 0);
             if(cmpBytes <= 0) break;
             write_int32(outFp, cmpBytes);
             write_bin(outFp, cmpBuf, cmpBytes);
@@ -90,7 +91,7 @@ void test_decompress(FILE* outFp, FILE* inpFp)
 
     for(;;) {
         int cmpBytes = 0;
-        char cmpBuf[LZ4_COMPRESSBOUND(MESSAGE_MAX_BYTES)];
+        char cmpBuf[CMPBUFSIZE];
 
         {
             const size_t r0 = read_int32(inpFp, &cmpBytes);

src/lz4/examples/compress_functions.c

@@ -0,0 +1,363 @@
+/*
+ * compress_functions.c
+ * Copyright  : Kyle Harper
+ * License    : Follows same licensing as the lz4.c/lz4.h program at any given time.  Currently, BSD 2.
+ * Description: A program to demonstrate the various compression functions involved in when using LZ4_compress_default().  The idea
+ *              is to show how each step in the call stack can be used directly, if desired.  There is also some benchmarking for
+ *              each function to demonstrate the (probably lack of) performance difference when jumping the stack.
+ *              (If you're new to lz4, please read simple_buffer.c to understand the fundamentals)
+ *
+ *              The call stack (before theoretical compiler optimizations) for LZ4_compress_default is as follows:
+ *                LZ4_compress_default
+ *                  LZ4_compress_fast
+ *                    LZ4_compress_fast_extState
+ *                      LZ4_compress_generic
+ *
+ *              LZ4_compress_default()
+ *                This is the recommended function for compressing data.  It will serve as the baseline for comparison.
+ *              LZ4_compress_fast()
+ *                Despite its name, it's not a "fast" version of compression.  It simply decides if HEAPMODE is set and either
+ *                allocates memory on the heap for a struct or creates the struct directly on the stack.  Stack access is generally
+ *                faster but this function itself isn't giving that advantage, it's just some logic for compile time.
+ *              LZ4_compress_fast_extState()
+ *                This simply accepts all the pointers and values collected thus far and adds logic to determine how
+ *                LZ4_compress_generic should be invoked; specifically: can the source fit into a single pass as determined by
+ *                LZ4_64Klimit.
+ *              LZ4_compress_generic()
+ *                As the name suggests, this is the generic function that ultimately does most of the heavy lifting.  Calling this
+ *                directly can help avoid some test cases and branching which might be useful in some implementation-specific
+ *                situations, but you really need to know what you're doing AND what you're asking lz4 to do!  You also need a
+ *                wrapper function because this function isn't exposed with lz4.h.
+ *
+ *              The call stack for decompression functions is shallow.  There are 2 options:
+ *                LZ4_decompress_safe  ||  LZ4_decompress_fast
+ *                  LZ4_decompress_generic
+ *
+ *               LZ4_decompress_safe
+ *                 This is the recommended function for decompressing data.  It is considered safe because the caller specifies
+ *                 both the size of the compresssed buffer to read as well as the maximum size of the output (decompressed) buffer
+ *                 instead of just the latter.
+ *               LZ4_decompress_fast
+ *                 Again, despite its name it's not a "fast" version of decompression.  It simply frees the caller of sending the
+ *                 size of the compressed buffer (it will simply be read-to-end, hence it's non-safety).
+ *               LZ4_decompress_generic
+ *                 This is the generic function that both of the LZ4_decompress_* functions above end up calling.  Calling this
+ *                 directly is not advised, period.  Furthermore, it is a static inline function in lz4.c, so there isn't a symbol
+ *                 exposed for anyone using lz4.h to utilize.
+ *
+ *               Special Note About Decompression:
+ *               Using the LZ4_decompress_safe() function protects against malicious (user) input.  If you are using data from a
+ *               trusted source, or if your program is the producer (P) as well as its consumer (C) in a PC or MPMC setup, you can
+ *               safely use the LZ4_decompress_fast function
+ */
+
+/* Since lz4 compiles with c99 and not gnu/std99 we need to enable POSIX linking for time.h structs and functions. */
+#if __STDC_VERSION__ >= 199901L
+#define _XOPEN_SOURCE 600
+#else
+#define _XOPEN_SOURCE 500
+#endif
+#define _POSIX_C_SOURCE 199309L
+
+/* Includes, for Power! */
+#include "lz4.h"
+#include <stdio.h>    /* for printf() */
+#include <stdlib.h>   /* for exit() */
+#include <string.h>   /* for atoi() memcmp() */
+#include <stdint.h>   /* for uint_types */
+#include <inttypes.h> /* for PRIu64 */
+#include <time.h>     /* for clock_gettime() */
+#include <locale.h>   /* for setlocale() */
+
+/* We need to know what one billion is for clock timing. */
+#define BILLION 1000000000L
+
+/* Create a crude set of test IDs so we can switch on them later  (Can't switch() on a char[] or char*). */
+#define ID__LZ4_COMPRESS_DEFAULT        1
+#define ID__LZ4_COMPRESS_FAST           2
+#define ID__LZ4_COMPRESS_FAST_EXTSTATE  3
+#define ID__LZ4_COMPRESS_GENERIC        4
+#define ID__LZ4_DECOMPRESS_SAFE         5
+#define ID__LZ4_DECOMPRESS_FAST         6
+
+
+
+/*
+ * Easy show-error-and-bail function.
+ */
+void run_screaming(const char *message, const int code) {
+  printf("%s\n", message);
+  exit(code);
+  return;
+}
+
+
+/*
+ * Centralize the usage function to keep main cleaner.
+ */
+void usage(const char *message) {
+  printf("Usage: ./argPerformanceTesting <iterations>\n");
+  run_screaming(message, 1);
+  return;
+}
+
+
+
+/*
+ * Runs the benchmark for LZ4_compress_* based on function_id.
+ */
+uint64_t bench(
+    const char *known_good_dst,
+    const int function_id,
+    const int iterations,
+    const char *src,
+    char *dst,
+    const size_t src_size,
+    const size_t max_dst_size,
+    const size_t comp_size
+  ) {
+  uint64_t time_taken = 0;
+  int rv = 0;
+  const int warm_up = 5000;
+  struct timespec start, end;
+  const int acceleration = 1;
+  LZ4_stream_t state;
+
+  // Select the right function to perform the benchmark on.  We perform 5000 initial loops to warm the cache and ensure that dst
+  // remains matching to known_good_dst between successive calls.
+  switch(function_id) {
+    case ID__LZ4_COMPRESS_DEFAULT:
+      printf("Starting benchmark for function: LZ4_compress_default()\n");
+      for(int junk=0; junk<warm_up; junk++)
+        rv = LZ4_compress_default(src, dst, src_size, max_dst_size);
+      if (rv < 1)
+        run_screaming("Couldn't run LZ4_compress_default()... error code received is in exit code.", rv);
+      if (memcmp(known_good_dst, dst, max_dst_size) != 0)
+        run_screaming("According to memcmp(), the compressed dst we got doesn't match the known_good_dst... ruh roh.", 1);
+      clock_gettime(CLOCK_MONOTONIC, &start);
+      for (int i=1; i<=iterations; i++)
+        LZ4_compress_default(src, dst, src_size, max_dst_size);
+      break;
+
+    case ID__LZ4_COMPRESS_FAST:
+      printf("Starting benchmark for function: LZ4_compress_fast()\n");
+      for(int junk=0; junk<warm_up; junk++)
+        rv = LZ4_compress_fast(src, dst, src_size, max_dst_size, acceleration);
+      if (rv < 1)
+        run_screaming("Couldn't run LZ4_compress_fast()... error code received is in exit code.", rv);
+      if (memcmp(known_good_dst, dst, max_dst_size) != 0)
+        run_screaming("According to memcmp(), the compressed dst we got doesn't match the known_good_dst... ruh roh.", 1);
+      clock_gettime(CLOCK_MONOTONIC, &start);
+      for (int i=1; i<=iterations; i++)
+        LZ4_compress_fast(src, dst, src_size, max_dst_size, acceleration);
+      break;
+
+    case ID__LZ4_COMPRESS_FAST_EXTSTATE:
+      printf("Starting benchmark for function: LZ4_compress_fast_extState()\n");
+      for(int junk=0; junk<warm_up; junk++)
+        rv = LZ4_compress_fast_extState(&state, src, dst, src_size, max_dst_size, acceleration);
+      if (rv < 1)
+        run_screaming("Couldn't run LZ4_compress_fast_extState()... error code received is in exit code.", rv);
+      if (memcmp(known_good_dst, dst, max_dst_size) != 0)
+        run_screaming("According to memcmp(), the compressed dst we got doesn't match the known_good_dst... ruh roh.", 1);
+      clock_gettime(CLOCK_MONOTONIC, &start);
+      for (int i=1; i<=iterations; i++)
+        LZ4_compress_fast_extState(&state, src, dst, src_size, max_dst_size, acceleration);
+      break;
+
+//    Disabled until LZ4_compress_generic() is exposed in the header.
+//    case ID__LZ4_COMPRESS_GENERIC:
+//      printf("Starting benchmark for function: LZ4_compress_generic()\n");
+//      LZ4_resetStream((LZ4_stream_t*)&state);
+//      for(int junk=0; junk<warm_up; junk++) {
+//        LZ4_resetStream((LZ4_stream_t*)&state);
+//        //rv = LZ4_compress_generic_wrapper(&state, src, dst, src_size, max_dst_size, notLimited, byU16, noDict, noDictIssue, acceleration);
+//        LZ4_compress_generic_wrapper(&state, src, dst, src_size, max_dst_size, acceleration);
+//      }
+//      if (rv < 1)
+//        run_screaming("Couldn't run LZ4_compress_generic()... error code received is in exit code.", rv);
+//      if (memcmp(known_good_dst, dst, max_dst_size) != 0)
+//        run_screaming("According to memcmp(), the compressed dst we got doesn't match the known_good_dst... ruh roh.", 1);
+//      for (int i=1; i<=iterations; i++) {
+//        LZ4_resetStream((LZ4_stream_t*)&state);
+//        //LZ4_compress_generic_wrapper(&state, src, dst, src_size, max_dst_size, notLimited, byU16, noDict, noDictIssue, acceleration);
+//        LZ4_compress_generic_wrapper(&state, src, dst, src_size, max_dst_size, acceleration);
+//      }
+//      break;
+
+    case ID__LZ4_DECOMPRESS_SAFE:
+      printf("Starting benchmark for function: LZ4_decompress_safe()\n");
+      for(int junk=0; junk<warm_up; junk++)
+        rv = LZ4_decompress_safe(src, dst, comp_size, src_size);
+      if (rv < 1)
+        run_screaming("Couldn't run LZ4_decompress_safe()... error code received is in exit code.", rv);
+      if (memcmp(known_good_dst, dst, src_size) != 0)
+        run_screaming("According to memcmp(), the compressed dst we got doesn't match the known_good_dst... ruh roh.", 1);
+      clock_gettime(CLOCK_MONOTONIC, &start);
+      for (int i=1; i<=iterations; i++)
+        LZ4_decompress_safe(src, dst, comp_size, src_size);
+      break;
+
+    case ID__LZ4_DECOMPRESS_FAST:
+      printf("Starting benchmark for function: LZ4_decompress_fast()\n");
+      for(int junk=0; junk<warm_up; junk++)
+        rv = LZ4_decompress_fast(src, dst, src_size);
+      if (rv < 1)
+        run_screaming("Couldn't run LZ4_decompress_fast()... error code received is in exit code.", rv);
+      if (memcmp(known_good_dst, dst, src_size) != 0)
+        run_screaming("According to memcmp(), the compressed dst we got doesn't match the known_good_dst... ruh roh.", 1);
+      clock_gettime(CLOCK_MONOTONIC, &start);
+      for (int i=1; i<=iterations; i++)
+        LZ4_decompress_fast(src, dst, src_size);
+      break;
+
+    default:
+      run_screaming("The test specified isn't valid.  Please check your code.", 1);
+      break;
+  }
+
+  // Stop timer and return time taken.
+  clock_gettime(CLOCK_MONOTONIC, &end);
+  time_taken = BILLION *(end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
+
+  return time_taken;
+}
+
+
+
+/*
+ * main()
+ * We will demonstrate the use of each function for simplicity sake.  Then we will run 2 suites of benchmarking:
+ * Test suite A)  Uses generic Lorem Ipsum text which should be generally compressible insomuch as basic human text is
+ *                compressible for such a small src_size
+ * Test Suite B)  For the sake of testing, see what results we get if the data is drastically easier to compress.  IF there are
+ *                indeed losses and IF more compressible data is faster to process, this will exacerbate the findings.
+ */
+int main(int argc, char **argv) {
+  // Get and verify options.  There's really only 1:  How many iterations to run.
+  int iterations = 1000000;
+  if (argc > 1)
+    iterations = atoi(argv[1]);
+  if (iterations < 1)
+    usage("Argument 1 (iterations) must be > 0.");
+
+  // First we will create 2 sources (char *) of 2000 bytes each.  One normal text, the other highly-compressible text.
+  const char *src    = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed luctus purus et risus vulputate, et mollis orci ullamcorper. Nulla facilisi. Fusce in ligula sed purus varius aliquet interdum vitae justo. Proin quis diam velit. Nulla varius iaculis auctor. Cras volutpat, justo eu dictum pulvinar, elit sem porttitor metus, et imperdiet metus sapien et ante. Nullam nisi nulla, ornare eu tristique eu, dignissim vitae diam. Nulla sagittis porta libero, a accumsan felis sagittis scelerisque.  Integer laoreet eleifend congue. Etiam rhoncus leo vel dolor fermentum, quis luctus nisl iaculis. Praesent a erat sapien. Aliquam semper mi in lorem ultrices ultricies. Lorem ipsum dolor sit amet, consectetur adipiscing elit. In feugiat risus sed enim ultrices, at sodales nulla tristique. Maecenas eget pellentesque justo, sed pellentesque lectus. Fusce sagittis sit amet elit vel varius. Donec sed ligula nec ligula vulputate rutrum sed ut lectus. Etiam congue pharetra leo vitae cursus. Morbi enim ante, porttitor ut varius vel, tincidunt quis justo. Nunc iaculis, risus id ultrices semper, metus est efficitur ligula, vel posuere risus nunc eget purus. Ut lorem turpis, condimentum at sem sed, porta aliquam turpis. In ut sapien a nulla dictum tincidunt quis sit amet lorem. Fusce at est egestas, luctus neque eu, consectetur tortor. Phasellus eleifend ultricies nulla ac lobortis.  Morbi maximus quam cursus vehicula iaculis. Maecenas cursus vel justo ut rutrum. Curabitur magna orci, dignissim eget dapibus vitae, finibus id lacus. Praesent rhoncus mattis augue vitae bibendum. Praesent porta mauris non ultrices fermentum. Quisque vulputate ipsum in sodales pulvinar. Aliquam nec mollis felis. Donec vitae augue pulvinar, congue nisl sed, pretium purus. Fusce lobortis mi ac neque scelerisque semper. Pellentesque vel est vitae magna aliquet aliquet. Nam non dolor. Nulla facilisi. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Morbi ac lacinia felis metus.";
+  const char *hc_src = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+  // Set and derive sizes.  Since we're using strings, use strlen() + 1 for \0.
+  const size_t src_size = strlen(src) + 1;
+  const size_t max_dst_size = LZ4_compressBound(src_size);
+  int bytes_returned = 0;
+  // Now build allocations for the data we'll be playing with.
+  char *dst               = calloc(1, max_dst_size);
+  char *known_good_dst    = calloc(1, max_dst_size);
+  char *known_good_hc_dst = calloc(1, max_dst_size);
+  if (dst == NULL || known_good_dst == NULL || known_good_hc_dst == NULL)
+    run_screaming("Couldn't allocate memory for the destination buffers.  Sad :(", 1);
+
+  // Create known-good buffers to verify our tests with other functions will produce the same results.
+  bytes_returned = LZ4_compress_default(src, known_good_dst, src_size, max_dst_size);
+  if (bytes_returned < 1)
+    run_screaming("Couldn't create a known-good destination buffer for comparison... this is bad.", 1);
+  const size_t src_comp_size = bytes_returned;
+  bytes_returned = LZ4_compress_default(hc_src, known_good_hc_dst, src_size, max_dst_size);
+  if (bytes_returned < 1)
+    run_screaming("Couldn't create a known-good (highly compressible) destination buffer for comparison... this is bad.", 1);
+  const size_t hc_src_comp_size = bytes_returned;
+
+
+  /* LZ4_compress_default() */
+  // This is the default function so we don't need to demonstrate how to use it.  See basics.c if you need more basal information.
+
+  /* LZ4_compress_fast() */
+  // Using this function is identical to LZ4_compress_default except we need to specify an "acceleration" value.  Defaults to 1.
+  memset(dst, 0, max_dst_size);
+  bytes_returned = LZ4_compress_fast(src, dst, src_size, max_dst_size, 1);
+  if (bytes_returned < 1)
+    run_screaming("Failed to compress src using LZ4_compress_fast.  echo $? for return code.", bytes_returned);
+  if (memcmp(dst, known_good_dst, bytes_returned) != 0)
+    run_screaming("According to memcmp(), the value we got in dst from LZ4_compress_fast doesn't match the known-good value.  This is bad.", 1);
+
+  /* LZ4_compress_fast_extState() */
+  // Using this function directly requires that we build an LZ4_stream_t struct ourselves.  We do NOT have to reset it ourselves.
+  memset(dst, 0, max_dst_size);
+  LZ4_stream_t state;
+  bytes_returned = LZ4_compress_fast_extState(&state, src, dst, src_size, max_dst_size, 1);
+  if (bytes_returned < 1)
+    run_screaming("Failed to compress src using LZ4_compress_fast_extState.  echo $? for return code.", bytes_returned);
+  if (memcmp(dst, known_good_dst, bytes_returned) != 0)
+    run_screaming("According to memcmp(), the value we got in dst from LZ4_compress_fast_extState doesn't match the known-good value.  This is bad.", 1);
+
+  /* LZ4_compress_generic */
+  // When you can exactly control the inputs and options of your LZ4 needs, you can use LZ4_compress_generic and fixed (const)
+  // values for the enum types such as dictionary and limitations.  Any other direct-use is probably a bad idea.
+  //
+  // That said, the LZ4_compress_generic() function is 'static inline' and does not have a prototype in lz4.h to expose a symbol
+  // for it.  In other words: we can't access it directly.  I don't want to submit a PR that modifies lz4.c/h.  Yann and others can
+  // do that if they feel it's worth expanding this example.
+  //
+  // I will, however, leave a skeleton of what would be required to use it directly:
+  /*
+    memset(dst, 0, max_dst_size);
+    // LZ4_stream_t state:  is already declared above.  We can reuse it BUT we have to reset the stream ourselves between each call.
+    LZ4_resetStream((LZ4_stream_t *)&state);
+    // Since src size is small we know the following enums will be used:  notLimited (0), byU16 (2), noDict (0), noDictIssue (0).
+    bytes_returned = LZ4_compress_generic(&state, src, dst, src_size, max_dst_size, notLimited, byU16, noDict, noDictIssue, 1);
+    if (bytes_returned < 1)
+      run_screaming("Failed to compress src using LZ4_compress_generic.  echo $? for return code.", bytes_returned);
+    if (memcmp(dst, known_good_dst, bytes_returned) != 0)
+      run_screaming("According to memcmp(), the value we got in dst from LZ4_compress_generic doesn't match the known-good value.  This is bad.", 1);
+  */
+
+
+  /* Benchmarking */
+  /* Now we'll run a few rudimentary benchmarks with each function to demonstrate differences in speed based on the function used.
+   * Remember, we cannot call LZ4_compress_generic() directly (yet) so it's disabled.
+   */
+  // Suite A - Normal Compressibility
+  char *dst_d = calloc(1, src_size);
+  memset(dst, 0, max_dst_size);
+  printf("\nStarting suite A:  Normal compressible text.\n");
+  uint64_t time_taken__default       = bench(known_good_dst, ID__LZ4_COMPRESS_DEFAULT,       iterations, src,            dst,   src_size, max_dst_size, src_comp_size);
+  uint64_t time_taken__fast          = bench(known_good_dst, ID__LZ4_COMPRESS_FAST,          iterations, src,            dst,   src_size, max_dst_size, src_comp_size);
+  uint64_t time_taken__fast_extstate = bench(known_good_dst, ID__LZ4_COMPRESS_FAST_EXTSTATE, iterations, src,            dst,   src_size, max_dst_size, src_comp_size);
+  //uint64_t time_taken__generic       = bench(known_good_dst, ID__LZ4_COMPRESS_GENERIC,       iterations, src,            dst,   src_size, max_dst_size, src_comp_size);
+  uint64_t time_taken__decomp_safe   = bench(src,            ID__LZ4_DECOMPRESS_SAFE,        iterations, known_good_dst, dst_d, src_size, max_dst_size, src_comp_size);
+  uint64_t time_taken__decomp_fast   = bench(src,            ID__LZ4_DECOMPRESS_FAST,        iterations, known_good_dst, dst_d, src_size, max_dst_size, src_comp_size);
+  // Suite B - Highly Compressible
+  memset(dst, 0, max_dst_size);
+  printf("\nStarting suite B:  Highly compressible text.\n");
+  uint64_t time_taken_hc__default       = bench(known_good_hc_dst, ID__LZ4_COMPRESS_DEFAULT,       iterations, hc_src,            dst,   src_size, max_dst_size, hc_src_comp_size);
+  uint64_t time_taken_hc__fast          = bench(known_good_hc_dst, ID__LZ4_COMPRESS_FAST,          iterations, hc_src,            dst,   src_size, max_dst_size, hc_src_comp_size);
+  uint64_t time_taken_hc__fast_extstate = bench(known_good_hc_dst, ID__LZ4_COMPRESS_FAST_EXTSTATE, iterations, hc_src,            dst,   src_size, max_dst_size, hc_src_comp_size);
+  //uint64_t time_taken_hc__generic       = bench(known_good_hc_dst, ID__LZ4_COMPRESS_GENERIC,       iterations, hc_src,            dst,   src_size, max_dst_size, hc_src_comp_size);
+  uint64_t time_taken_hc__decomp_safe   = bench(hc_src,            ID__LZ4_DECOMPRESS_SAFE,        iterations, known_good_hc_dst, dst_d, src_size, max_dst_size, hc_src_comp_size);
+  uint64_t time_taken_hc__decomp_fast   = bench(hc_src,            ID__LZ4_DECOMPRESS_FAST,        iterations, known_good_hc_dst, dst_d, src_size, max_dst_size, hc_src_comp_size);
+
+  // Report and leave.
+  setlocale(LC_ALL, "");
+  const char *format        = "|%-14s|%-30s|%'14.9f|%'16d|%'14d|%'13.2f%%|\n";
+  const char *header_format = "|%-14s|%-30s|%14s|%16s|%14s|%14s|\n";
+  const char *separator     = "+--------------+------------------------------+--------------+----------------+--------------+--------------+\n";
+  printf("\n");
+  printf("%s", separator);
+  printf(header_format, "Source", "Function Benchmarked", "Total Seconds", "Iterations/sec", "ns/Iteration", "% of default");
+  printf("%s", separator);
+  printf(format, "Normal Text", "LZ4_compress_default()",       (double)time_taken__default       / BILLION, (int)(iterations / ((double)time_taken__default       /BILLION)), time_taken__default       / iterations, (double)time_taken__default       * 100 / time_taken__default);
+  printf(format, "Normal Text", "LZ4_compress_fast()",          (double)time_taken__fast          / BILLION, (int)(iterations / ((double)time_taken__fast          /BILLION)), time_taken__fast          / iterations, (double)time_taken__fast          * 100 / time_taken__default);
+  printf(format, "Normal Text", "LZ4_compress_fast_extState()", (double)time_taken__fast_extstate / BILLION, (int)(iterations / ((double)time_taken__fast_extstate /BILLION)), time_taken__fast_extstate / iterations, (double)time_taken__fast_extstate * 100 / time_taken__default);
+  //printf(format, "Normal Text", "LZ4_compress_generic()",       (double)time_taken__generic       / BILLION, (int)(iterations / ((double)time_taken__generic       /BILLION)), time_taken__generic       / iterations, (double)time_taken__generic       * 100 / time_taken__default);
+  printf(format, "Normal Text", "LZ4_decompress_safe()",        (double)time_taken__decomp_safe   / BILLION, (int)(iterations / ((double)time_taken__decomp_safe   /BILLION)), time_taken__decomp_safe   / iterations, (double)time_taken__decomp_safe   * 100 / time_taken__default);
+  printf(format, "Normal Text", "LZ4_decompress_fast()",        (double)time_taken__decomp_fast   / BILLION, (int)(iterations / ((double)time_taken__decomp_fast   /BILLION)), time_taken__decomp_fast   / iterations, (double)time_taken__decomp_fast   * 100 / time_taken__default);
+  printf(header_format, "", "", "", "", "", "");
+  printf(format, "Compressible", "LZ4_compress_default()",       (double)time_taken_hc__default       / BILLION, (int)(iterations / ((double)time_taken_hc__default       /BILLION)), time_taken_hc__default       / iterations, (double)time_taken_hc__default       * 100 / time_taken_hc__default);
+  printf(format, "Compressible", "LZ4_compress_fast()",          (double)time_taken_hc__fast          / BILLION, (int)(iterations / ((double)time_taken_hc__fast          /BILLION)), time_taken_hc__fast          / iterations, (double)time_taken_hc__fast          * 100 / time_taken_hc__default);
+  printf(format, "Compressible", "LZ4_compress_fast_extState()", (double)time_taken_hc__fast_extstate / BILLION, (int)(iterations / ((double)time_taken_hc__fast_extstate /BILLION)), time_taken_hc__fast_extstate / iterations, (double)time_taken_hc__fast_extstate * 100 / time_taken_hc__default);
+  //printf(format, "Compressible", "LZ4_compress_generic()",       (double)time_taken_hc__generic       / BILLION, (int)(iterations / ((double)time_taken_hc__generic       /BILLION)), time_taken_hc__generic       / iterations, (double)time_taken_hc__generic       * 100 / time_taken_hc__default);
+  printf(format, "Compressible", "LZ4_decompress_safe()",        (double)time_taken_hc__decomp_safe   / BILLION, (int)(iterations / ((double)time_taken_hc__decomp_safe   /BILLION)), time_taken_hc__decomp_safe   / iterations, (double)time_taken_hc__decomp_safe   * 100 / time_taken_hc__default);
+  printf(format, "Compressible", "LZ4_decompress_fast()",        (double)time_taken_hc__decomp_fast   / BILLION, (int)(iterations / ((double)time_taken_hc__decomp_fast   /BILLION)), time_taken_hc__decomp_fast   / iterations, (double)time_taken_hc__decomp_fast   * 100 / time_taken_hc__default);
+  printf("%s", separator);
+  printf("\n");
+  printf("All done, ran %d iterations per test.\n", iterations);
+  return 0;
+}

src/lz4/examples/dictionaryRandomAccess.c

@@ -0,0 +1,280 @@
+// LZ4 API example : Dictionary Random Access
+
+#ifdef _MSC_VER    /* Visual Studio */
+#  define _CRT_SECURE_NO_WARNINGS
+#  define snprintf sprintf_s
+#endif
+#include "lz4.h"
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MIN(x, y) (x) < (y) ? (x) : (y)
+
+enum {
+    BLOCK_BYTES = 1024,  /* 1 KiB of uncompressed data in a block */
+    DICTIONARY_BYTES = 1024, /* Load a 1 KiB dictionary */
+    MAX_BLOCKS = 1024 /* For simplicity of implementation */
+};
+
+/**
+ * Magic bytes for this test case.
+ * This is not a great magic number because it is a common word in ASCII.
+ * However, it is important to have some versioning system in your format.
+ */
+const char kTestMagic[] = { 'T', 'E', 'S', 'T' };
+
+
+void write_int(FILE* fp, int i) {
+    size_t written = fwrite(&i, sizeof(i), 1, fp);
+    if (written != 1) { exit(10); }
+}
+
+void write_bin(FILE* fp, const void* array, size_t arrayBytes) {
+    size_t written = fwrite(array, 1, arrayBytes, fp);
+    if (written != arrayBytes) { exit(11); }
+}
+
+void read_int(FILE* fp, int* i) {
+    size_t read = fread(i, sizeof(*i), 1, fp);
+    if (read != 1) { exit(12); }
+}
+
+size_t read_bin(FILE* fp, void* array, size_t arrayBytes) {
+    size_t read = fread(array, 1, arrayBytes, fp);
+    if (ferror(fp)) { exit(12); }
+    return read;
+}
+
+void seek_bin(FILE* fp, long offset, int origin) {
+    if (fseek(fp, offset, origin)) { exit(14); }
+}
+
+
+void test_compress(FILE* outFp, FILE* inpFp, void *dict, int dictSize)
+{
+    LZ4_stream_t lz4Stream_body;
+    LZ4_stream_t* lz4Stream = &lz4Stream_body;
+
+    char inpBuf[BLOCK_BYTES];
+    int offsets[MAX_BLOCKS];
+    int *offsetsEnd = offsets;
+
+
+    LZ4_resetStream(lz4Stream);
+
+    /* Write header magic */
+    write_bin(outFp, kTestMagic, sizeof(kTestMagic));
+
+    *offsetsEnd++ = sizeof(kTestMagic);
+    /* Write compressed data blocks.  Each block contains BLOCK_BYTES of plain
+       data except possibly the last. */
+    for(;;) {
+        const int inpBytes = (int) read_bin(inpFp, inpBuf, BLOCK_BYTES);
+        if(0 == inpBytes) {
+            break;
+        }
+
+        /* Forget previously compressed data and load the dictionary */
+        LZ4_loadDict(lz4Stream, dict, dictSize);
+        {
+            char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
+            const int cmpBytes = LZ4_compress_fast_continue(
+                lz4Stream, inpBuf, cmpBuf, inpBytes, sizeof(cmpBuf), 1);
+            if(cmpBytes <= 0) { exit(1); }
+            write_bin(outFp, cmpBuf, (size_t)cmpBytes);
+            /* Keep track of the offsets */
+            *offsetsEnd = *(offsetsEnd - 1) + cmpBytes;
+            ++offsetsEnd;
+        }
+        if (offsetsEnd - offsets > MAX_BLOCKS) { exit(2); }
+    }
+    /* Write the tailing jump table */
+    {
+        int *ptr = offsets;
+        while (ptr != offsetsEnd) {
+            write_int(outFp, *ptr++);
+        }
+        write_int(outFp, offsetsEnd - offsets);
+    }
+}
+
+
+void test_decompress(FILE* outFp, FILE* inpFp, void *dict, int dictSize, int offset, int length)
+{
+    LZ4_streamDecode_t lz4StreamDecode_body;
+    LZ4_streamDecode_t* lz4StreamDecode = &lz4StreamDecode_body;
+
+    /* The blocks [currentBlock, endBlock) contain the data we want */
+    int currentBlock = offset / BLOCK_BYTES;
+    int endBlock = ((offset + length - 1) / BLOCK_BYTES) + 1;
+
+    char decBuf[BLOCK_BYTES];
+    int offsets[MAX_BLOCKS];
+
+    /* Special cases */
+    if (length == 0) { return; }
+
+    /* Read the magic bytes */
+    {
+        char magic[sizeof(kTestMagic)];
+        size_t read = read_bin(inpFp, magic, sizeof(magic));
+        if (read != sizeof(magic)) { exit(1); }
+        if (memcmp(kTestMagic, magic, sizeof(magic))) { exit(2); }
+    }
+
+    /* Read the offsets tail */
+    {
+        int numOffsets;
+        int block;
+        int *offsetsPtr = offsets;
+        seek_bin(inpFp, -4, SEEK_END);
+        read_int(inpFp, &numOffsets);
+        if (numOffsets <= endBlock) { exit(3); }
+        seek_bin(inpFp, -4 * (numOffsets + 1), SEEK_END);
+        for (block = 0; block <= endBlock; ++block) {
+            read_int(inpFp, offsetsPtr++);
+        }
+    }
+    /* Seek to the first block to read */
+    seek_bin(inpFp, offsets[currentBlock], SEEK_SET);
+    offset = offset % BLOCK_BYTES;
+
+    /* Start decoding */
+    for(; currentBlock < endBlock; ++currentBlock) {
+        char cmpBuf[LZ4_COMPRESSBOUND(BLOCK_BYTES)];
+        /* The difference in offsets is the size of the block */
+        int  cmpBytes = offsets[currentBlock + 1] - offsets[currentBlock];
+        {
+            const size_t read = read_bin(inpFp, cmpBuf, (size_t)cmpBytes);
+            if(read != (size_t)cmpBytes) { exit(4); }
+        }
+
+        /* Load the dictionary */
+        LZ4_setStreamDecode(lz4StreamDecode, dict, dictSize);
+        {
+            const int decBytes = LZ4_decompress_safe_continue(
+                lz4StreamDecode, cmpBuf, decBuf, cmpBytes, BLOCK_BYTES);
+            if(decBytes <= 0) { exit(5); }
+            {
+                /* Write out the part of the data we care about */
+                int blockLength = MIN(length, (decBytes - offset));
+                write_bin(outFp, decBuf + offset, (size_t)blockLength);
+                offset = 0;
+                length -= blockLength;
+            }
+        }
+    }
+}
+
+
+int compare(FILE* fp0, FILE* fp1, int length)
+{
+    int result = 0;
+
+    while(0 == result) {
+        char b0[4096];
+        char b1[4096];
+        const size_t r0 = read_bin(fp0, b0, MIN(length, (int)sizeof(b0)));
+        const size_t r1 = read_bin(fp1, b1, MIN(length, (int)sizeof(b1)));
+
+        result = (int) r0 - (int) r1;
+
+        if(0 == r0 || 0 == r1) {
+            break;
+        }
+        if(0 == result) {
+            result = memcmp(b0, b1, r0);
+        }
+        length -= r0;
+    }
+
+    return result;
+}
+
+
+int main(int argc, char* argv[])
+{
+    char inpFilename[256] = { 0 };
+    char lz4Filename[256] = { 0 };
+    char decFilename[256] = { 0 };
+    char dictFilename[256] = { 0 };
+    int offset;
+    int length;
+    char dict[DICTIONARY_BYTES];
+    int dictSize;
+
+    if(argc < 5) {
+        printf("Usage: %s input dictionary offset length", argv[0]);
+        return 0;
+    }
+
+    snprintf(inpFilename, 256, "%s", argv[1]);
+    snprintf(lz4Filename, 256, "%s.lz4s-%d", argv[1], BLOCK_BYTES);
+    snprintf(decFilename, 256, "%s.lz4s-%d.dec", argv[1], BLOCK_BYTES);
+    snprintf(dictFilename, 256, "%s", argv[2]);
+    offset = atoi(argv[3]);
+    length = atoi(argv[4]);
+
+    printf("inp    = [%s]\n", inpFilename);
+    printf("lz4    = [%s]\n", lz4Filename);
+    printf("dec    = [%s]\n", decFilename);
+    printf("dict   = [%s]\n", dictFilename);
+    printf("offset = [%d]\n", offset);
+    printf("length = [%d]\n", length);
+
+    /* Load dictionary */
+    {
+        FILE* dictFp = fopen(dictFilename, "rb");
+        dictSize = (int)read_bin(dictFp, dict, DICTIONARY_BYTES);
+        fclose(dictFp);
+    }
+
+    /* compress */
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* outFp = fopen(lz4Filename, "wb");
+
+        printf("compress : %s -> %s\n", inpFilename, lz4Filename);
+        test_compress(outFp, inpFp, dict, dictSize);
+        printf("compress : done\n");
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    /* decompress */
+    {
+        FILE* inpFp = fopen(lz4Filename, "rb");
+        FILE* outFp = fopen(decFilename, "wb");
+
+        printf("decompress : %s -> %s\n", lz4Filename, decFilename);
+        test_decompress(outFp, inpFp, dict, DICTIONARY_BYTES, offset, length);
+        printf("decompress : done\n");
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    /* verify */
+    {
+        FILE* inpFp = fopen(inpFilename, "rb");
+        FILE* decFp = fopen(decFilename, "rb");
+        seek_bin(inpFp, offset, SEEK_SET);
+
+        printf("verify : %s <-> %s\n", inpFilename, decFilename);
+        const int cmp = compare(inpFp, decFp, length);
+        if(0 == cmp) {
+            printf("verify : OK\n");
+        } else {
+            printf("verify : NG\n");
+        }
+
+        fclose(decFp);
+        fclose(inpFp);
+    }
+
+    return 0;
+}

src/lz4/examples/dictionaryRandomAccess.md

@@ -0,0 +1,67 @@
+# LZ4 API Example : Dictionary Random Access
+
+`dictionaryRandomAccess.c` is LZ4 API example which implements dictionary compression and random access decompression.
+
+Please note that the output file is not compatible with lz4frame and is platform dependent.
+
+
+## What's the point of this example ?
+
+ - Dictionary based compression for homogenous files.
+ - Random access to compressed blocks.
+
+
+## How the compression works
+
+Reads the dictionary from a file, and uses it as the history for each block.
+This allows each block to be independent, but maintains compression ratio.
+
+```
+    Dictionary
+         +
+         |
+         v
+    +---------+
+    | Block#1 |
+    +----+----+
+         |
+         v
+      {Out#1}
+
+
+    Dictionary
+         +
+         |
+         v
+    +---------+
+    | Block#2 |
+    +----+----+
+         |
+         v
+      {Out#2}
+```
+
+After writing the magic bytes `TEST` and then the compressed blocks, write out the jump table.
+The last 4 bytes is an integer containing the number of blocks in the stream.
+If there are `N` blocks, then just before the last 4 bytes is `N + 1` 4 byte integers containing the offsets at the beginning and end of each block.
+Let `Offset#K` be the total number of bytes written after writing out `Block#K` *including* the magic bytes for simplicity.
+
+```
++------+---------+     +---------+---+----------+     +----------+-----+
+| TEST | Block#1 | ... | Block#N | 4 | Offset#1 | ... | Offset#N | N+1 |
++------+---------+     +---------+---+----------+     +----------+-----+
+```
+
+## How the decompression works
+
+Decompression will do reverse order.
+
+ - Seek to the last 4 bytes of the file and read the number of offsets.
+ - Read each offset into an array.
+ - Seek to the first block containing data we want to read.
+   We know where to look because we know each block contains a fixed amount of uncompressed data, except possibly the last.
+ - Decompress it and write what data we need from it to the file.
+ - Read the next block.
+ - Decompress it and write that page to the file.
+
+Continue these procedure until all the required data has been read.

src/lz4/examples/frameCompress.c

@@ -0,0 +1,312 @@
+// LZ4frame API example : compress a file
+// Based on sample code from Zbigniew Jędrzejewski-Szmek
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <lz4frame.h>
+
+#define BUF_SIZE 16*1024
+#define LZ4_HEADER_SIZE 19
+#define LZ4_FOOTER_SIZE 4
+
+static const LZ4F_preferences_t lz4_preferences = {
+    { LZ4F_max256KB, LZ4F_blockLinked, LZ4F_noContentChecksum, LZ4F_frame,
+      0 /* content size unknown */, 0 /* no dictID */ , LZ4F_noBlockChecksum },
+    0,   /* compression level */
+    0,   /* autoflush */
+    { 0, 0, 0, 0 },  /* reserved, must be set to 0 */
+};
+
+static size_t compress_file(FILE *in, FILE *out, size_t *size_in, size_t *size_out) {
+    LZ4F_errorCode_t r;
+    LZ4F_compressionContext_t ctx;
+    char *src, *buf = NULL;
+    size_t size, n, k, count_in = 0, count_out, offset = 0, frame_size;
+
+    r = LZ4F_createCompressionContext(&ctx, LZ4F_VERSION);
+    if (LZ4F_isError(r)) {
+        printf("Failed to create context: error %zu\n", r);
+        return 1;
+    }
+    r = 1;  /* function result; 1 == error, by default (early exit) */
+
+    src = malloc(BUF_SIZE);
+    if (!src) {
+        printf("Not enough memory\n");
+        goto cleanup;
+    }
+
+    frame_size = LZ4F_compressBound(BUF_SIZE, &lz4_preferences);
+    size =  frame_size + LZ4_HEADER_SIZE + LZ4_FOOTER_SIZE;
+    buf = malloc(size);
+    if (!buf) {
+        printf("Not enough memory\n");
+        goto cleanup;
+    }
+
+    n = offset = count_out = LZ4F_compressBegin(ctx, buf, size, &lz4_preferences);
+    if (LZ4F_isError(n)) {
+        printf("Failed to start compression: error %zu\n", n);
+        goto cleanup;
+    }
+
+    printf("Buffer size is %zu bytes, header size %zu bytes\n", size, n);
+
+    for (;;) {
+        k = fread(src, 1, BUF_SIZE, in);
+        if (k == 0)
+            break;
+        count_in += k;
+
+        n = LZ4F_compressUpdate(ctx, buf + offset, size - offset, src, k, NULL);
+        if (LZ4F_isError(n)) {
+            printf("Compression failed: error %zu\n", n);
+            goto cleanup;
+        }
+
+        offset += n;
+        count_out += n;
+        if (size - offset < frame_size + LZ4_FOOTER_SIZE) {
+            printf("Writing %zu bytes\n", offset);
+
+            k = fwrite(buf, 1, offset, out);
+            if (k < offset) {
+                if (ferror(out))
+                    printf("Write failed\n");
+                else
+                    printf("Short write\n");
+                goto cleanup;
+            }
+
+            offset = 0;
+        }
+    }
+
+    n = LZ4F_compressEnd(ctx, buf + offset, size - offset, NULL);
+    if (LZ4F_isError(n)) {
+        printf("Failed to end compression: error %zu\n", n);
+        goto cleanup;
+    }
+
+    offset += n;
+    count_out += n;
+    printf("Writing %zu bytes\n", offset);
+
+    k = fwrite(buf, 1, offset, out);
+    if (k < offset) {
+        if (ferror(out))
+            printf("Write failed\n");
+        else
+            printf("Short write\n");
+        goto cleanup;
+    }
+
+    *size_in = count_in;
+    *size_out = count_out;
+    r = 0;
+ cleanup:
+    if (ctx)
+        LZ4F_freeCompressionContext(ctx);
+    free(src);
+    free(buf);
+    return r;
+}
+
+static size_t get_block_size(const LZ4F_frameInfo_t* info) {
+    switch (info->blockSizeID) {
+        case LZ4F_default:
+        case LZ4F_max64KB:  return 1 << 16;
+        case LZ4F_max256KB: return 1 << 18;
+        case LZ4F_max1MB:   return 1 << 20;
+        case LZ4F_max4MB:   return 1 << 22;
+        default:
+            printf("Impossible unless more block sizes are allowed\n");
+            exit(1);
+    }
+}
+
+static size_t decompress_file(FILE *in, FILE *out) {
+    void* const src = malloc(BUF_SIZE);
+    void* dst = NULL;
+    size_t dstCapacity = 0;
+    LZ4F_dctx *dctx = NULL;
+    size_t ret;
+
+    /* Initialization */
+    if (!src) { perror("decompress_file(src)"); goto cleanup; }
+    ret = LZ4F_createDecompressionContext(&dctx, 100);
+    if (LZ4F_isError(ret)) {
+        printf("LZ4F_dctx creation error: %s\n", LZ4F_getErrorName(ret));
+        goto cleanup;
+    }
+
+    /* Decompression */
+    ret = 1;
+    while (ret != 0) {
+        /* Load more input */
+        size_t srcSize = fread(src, 1, BUF_SIZE, in);
+        void* srcPtr = src;
+        void* srcEnd = srcPtr + srcSize;
+        if (srcSize == 0 || ferror(in)) {
+            printf("Decompress: not enough input or error reading file\n");
+            goto cleanup;
+        }
+        /* Allocate destination buffer if it isn't already */
+        if (!dst) {
+            LZ4F_frameInfo_t info;
+            ret = LZ4F_getFrameInfo(dctx, &info, src, &srcSize);
+            if (LZ4F_isError(ret)) {
+                printf("LZ4F_getFrameInfo error: %s\n", LZ4F_getErrorName(ret));
+                goto cleanup;
+            }
+            /* Allocating enough space for an entire block isn't necessary for
+             * correctness, but it allows some memcpy's to be elided.
+             */
+            dstCapacity = get_block_size(&info);
+            dst = malloc(dstCapacity);
+            if (!dst) { perror("decompress_file(dst)"); goto cleanup; }
+            srcPtr += srcSize;
+            srcSize = srcEnd - srcPtr;
+        }
+        /* Decompress:
+         * Continue while there is more input to read and the frame isn't over.
+         * If srcPtr == srcEnd then we know that there is no more output left in the
+         * internal buffer left to flush.
+         */
+        while (srcPtr != srcEnd && ret != 0) {
+            /* INVARIANT: Any data left in dst has already been written */
+            size_t dstSize = dstCapacity;
+            ret = LZ4F_decompress(dctx, dst, &dstSize, srcPtr, &srcSize, /* LZ4F_decompressOptions_t */ NULL);
+            if (LZ4F_isError(ret)) {
+                printf("Decompression error: %s\n", LZ4F_getErrorName(ret));
+                goto cleanup;
+            }
+            /* Flush output */
+            if (dstSize != 0){
+                size_t written = fwrite(dst, 1, dstSize, out);
+                printf("Writing %zu bytes\n", dstSize);
+                if (written != dstSize) {
+                    printf("Decompress: Failed to write to file\n");
+                    goto cleanup;
+                }
+            }
+            /* Update input */
+            srcPtr += srcSize;
+            srcSize = srcEnd - srcPtr;
+        }
+    }
+    /* Check that there isn't trailing input data after the frame.
+     * It is valid to have multiple frames in the same file, but this example
+     * doesn't support it.
+     */
+    ret = fread(src, 1, 1, in);
+    if (ret != 0 || !feof(in)) {
+        printf("Decompress: Trailing data left in file after frame\n");
+        goto cleanup;
+    }
+
+cleanup:
+    free(src);
+    free(dst);
+    return LZ4F_freeDecompressionContext(dctx);   /* note : free works on NULL */
+}
+
+int compare(FILE* fp0, FILE* fp1)
+{
+    int result = 0;
+
+    while(0 == result) {
+        char b0[1024];
+        char b1[1024];
+        const size_t r0 = fread(b0, 1, sizeof(b0), fp0);
+        const size_t r1 = fread(b1, 1, sizeof(b1), fp1);
+
+        result = (int) r0 - (int) r1;
+
+        if (0 == r0 || 0 == r1) {
+            break;
+        }
+        if (0 == result) {
+            result = memcmp(b0, b1, r0);
+        }
+    }
+
+    return result;
+}
+
+int main(int argc, const char **argv) {
+    char inpFilename[256] = { 0 };
+    char lz4Filename[256] = { 0 };
+    char decFilename[256] = { 0 };
+
+    if(argc < 2) {
+        printf("Please specify input filename\n");
+        return 0;
+    }
+
+    snprintf(inpFilename, 256, "%s", argv[1]);
+    snprintf(lz4Filename, 256, "%s.lz4", argv[1]);
+    snprintf(decFilename, 256, "%s.lz4.dec", argv[1]);
+
+    printf("inp = [%s]\n", inpFilename);
+    printf("lz4 = [%s]\n", lz4Filename);
+    printf("dec = [%s]\n", decFilename);
+
+    /* compress */
+    {   FILE* const inpFp = fopen(inpFilename, "rb");
+        FILE* const outFp = fopen(lz4Filename, "wb");
+        size_t sizeIn = 0;
+        size_t sizeOut = 0;
+        size_t ret;
+
+        printf("compress : %s -> %s\n", inpFilename, lz4Filename);
+        ret = compress_file(inpFp, outFp, &sizeIn, &sizeOut);
+        if (ret) {
+            printf("compress : failed with code %zu\n", ret);
+            return (int)ret;
+        }
+        printf("%s: %zu → %zu bytes, %.1f%%\n",
+            inpFilename, sizeIn, sizeOut,
+            (double)sizeOut / sizeIn * 100);
+        printf("compress : done\n");
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    /* decompress */
+    {   FILE* const inpFp = fopen(lz4Filename, "rb");
+        FILE* const outFp = fopen(decFilename, "wb");
+        size_t ret;
+
+        printf("decompress : %s -> %s\n", lz4Filename, decFilename);
+        ret = decompress_file(inpFp, outFp);
+        if (ret) {
+            printf("decompress : failed with code %zu\n", ret);
+            return (int)ret;
+        }
+        printf("decompress : done\n");
+
+        fclose(outFp);
+        fclose(inpFp);
+    }
+
+    /* verify */
+    {   FILE* const inpFp = fopen(inpFilename, "rb");
+        FILE* const decFp = fopen(decFilename, "rb");
+
+        printf("verify : %s <-> %s\n", inpFilename, decFilename);
+        const int cmp = compare(inpFp, decFp);
+        if(0 == cmp) {
+            printf("verify : OK\n");
+        } else {
+            printf("verify : NG\n");
+        }
+
+        fclose(decFp);
+        fclose(inpFp);
+    }
+}

src/lz4/examples/simple_buffer.c

@@ -0,0 +1,94 @@
+/*
+ * simple_buffer.c
+ * Copyright  : Kyle Harper
+ * License    : Follows same licensing as the lz4.c/lz4.h program at any given time.  Currently, BSD 2.
+ * Description: Example program to demonstrate the basic usage of the compress/decompress functions within lz4.c/lz4.h.
+ *              The functions you'll likely want are LZ4_compress_default and LZ4_decompress_safe.  Both of these are documented in
+ *              the lz4.h header file; I recommend reading them.
+ */
+
+/* Includes, for Power! */
+#include "lz4.h"     // This is all that is required to expose the prototypes for basic compression and decompression.
+#include <stdio.h>   // For printf()
+#include <string.h>  // For memcmp()
+#include <stdlib.h>  // For exit()
+
+/*
+ * Easy show-error-and-bail function.
+ */
+void run_screaming(const char *message, const int code) {
+  printf("%s\n", message);
+  exit(code);
+  return;
+}
+
+
+/*
+ * main
+ */
+int main(void) {
+  /* Introduction */
+  // Below we will have a Compression and Decompression section to demonstrate.
+  // There are a few important notes before we start:
+  //   1) The return codes of LZ4_ functions are important.
+  //      Read lz4.h if you're unsure what a given code means.
+  //   2) LZ4 uses char* pointers in all LZ4_ functions.
+  //      This is baked into the API and probably not going to change.
+  //      If your program uses pointers that are unsigned char*, void*, or otherwise different,
+  //      you may need to do some casting or set the right -W compiler flags to ignore those warnings (e.g.: -Wno-pointer-sign).
+
+  /* Compression */
+  // We'll store some text into a variable pointed to by *src to be compressed later.
+  const char* const src = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+  // The compression function needs to know how many bytes exist.  Since we're using a string, we can use strlen() + 1 (for \0).
+  const int src_size = (int)(strlen(src) + 1);
+  // LZ4 provides a function that will tell you the maximum size of compressed output based on input data via LZ4_compressBound().
+  const int max_dst_size = LZ4_compressBound(src_size);
+  // We will use that size for our destination boundary when allocating space.
+  char* compressed_data = malloc(max_dst_size);
+  if (compressed_data == NULL)
+    run_screaming("Failed to allocate memory for *compressed_data.", 1);
+  // That's all the information and preparation LZ4 needs to compress *src into *compressed_data.
+  // Invoke LZ4_compress_default now with our size values and pointers to our memory locations.
+  // Save the return value for error checking.
+  const int compressed_data_size = LZ4_compress_default(src, compressed_data, src_size, max_dst_size);
+  // Check return_value to determine what happened.
+  if (compressed_data_size < 0)
+    run_screaming("A negative result from LZ4_compress_default indicates a failure trying to compress the data.  See exit code (echo $?) for value returned.", compressed_data_size);
+  if (compressed_data_size == 0)
+    run_screaming("A result of 0 means compression worked, but was stopped because the destination buffer couldn't hold all the information.", 1);
+  if (compressed_data_size > 0)
+    printf("We successfully compressed some data!\n");
+  // Not only does a positive return_value mean success, the value returned == the number of bytes required.
+  // You can use this to realloc() *compress_data to free up memory, if desired.  We'll do so just to demonstrate the concept.
+  compressed_data = (char *)realloc(compressed_data, compressed_data_size);
+  if (compressed_data == NULL)
+    run_screaming("Failed to re-alloc memory for compressed_data.  Sad :(", 1);
+
+  /* Decompression */
+  // Now that we've successfully compressed the information from *src to *compressed_data, let's do the opposite!  We'll create a
+  // *new_src location of size src_size since we know that value.
+  char* const regen_buffer = malloc(src_size);
+  if (regen_buffer == NULL)
+    run_screaming("Failed to allocate memory for *regen_buffer.", 1);
+  // The LZ4_decompress_safe function needs to know where the compressed data is, how many bytes long it is,
+  // where the regen_buffer memory location is, and how large regen_buffer (uncompressed) output will be.
+  // Again, save the return_value.
+  const int decompressed_size = LZ4_decompress_safe(compressed_data, regen_buffer, compressed_data_size, src_size);
+  free(compressed_data);   /* no longer useful */
+  if (decompressed_size < 0)
+    run_screaming("A negative result from LZ4_decompress_safe indicates a failure trying to decompress the data.  See exit code (echo $?) for value returned.", decompressed_size);
+  if (decompressed_size == 0)
+    run_screaming("I'm not sure this function can ever return 0.  Documentation in lz4.h doesn't indicate so.", 1);
+  if (decompressed_size > 0)
+    printf("We successfully decompressed some data!\n");
+  // Not only does a positive return value mean success,
+  // value returned == number of bytes regenerated from compressed_data stream.
+
+  /* Validation */
+  // We should be able to compare our original *src with our *new_src and be byte-for-byte identical.
+  if (memcmp(src, regen_buffer, src_size) != 0)
+    run_screaming("Validation failed.  *src and *new_src are not identical.", 1);
+  printf("Validation done.  The string we ended up with is:\n%s\n", regen_buffer);
+  return 0;
+}

src/lz4/examples/streaming_api_basics.md

@@ -39,7 +39,7 @@ Example (1) : Block API, 4KiB Block
     +---------------+---------------+----+----+----+
     | Block #1      | Block #2      | #3 | #4 |... |
     +---------------+---------------+----+----+----+
-    
+
                     (No Dependency)
 
 

src/lz4/lib/.gitignore

@@ -0,0 +1,2 @@
+# make install artefact
+liblz4.pc

src/lz4/lib/Makefile

@@ -1,19 +1,21 @@
 # ################################################################
 # LZ4 library - Makefile
-# Copyright (C) Yann Collet 2011-2015
+# Copyright (C) Yann Collet 2011-2016
 # All rights reserved.
-# 
+#
+# This Makefile is validated for Linux, macOS, *BSD, Hurd, Solaris, MSYS2 targets
+#
 # BSD license
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
-# 
+#
 # * Redistributions of source code must retain the above copyright notice, this
 #   list of conditions and the following disclaimer.
-# 
+#
 # * Redistributions in binary form must reproduce the above copyright notice, this
 #   list of conditions and the following disclaimer in the documentation and/or
 #   other materials provided with the distribution.
-# 
+#
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
@@ -24,26 +26,32 @@
 # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-# 
+#
 # You can contact the author at :
 #  - LZ4 source repository : https://github.com/Cyan4973/lz4
 #  - LZ4 forum froup : https://groups.google.com/forum/#!forum/lz4c
 # ################################################################
 
 # Version numbers
-VERSION ?= 129
-LIBVER_MAJOR=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h`
-LIBVER_MINOR=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h`
-LIBVER_PATCH=`sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < lz4.h`
-LIBVER=$(LIBVER_MAJOR).$(LIBVER_MINOR).$(LIBVER_PATCH)
+LIBVER_MAJOR_SCRIPT:=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ./lz4.h`
+LIBVER_MINOR_SCRIPT:=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ./lz4.h`
+LIBVER_PATCH_SCRIPT:=`sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < ./lz4.h`
+LIBVER_SCRIPT:= $(LIBVER_MAJOR_SCRIPT).$(LIBVER_MINOR_SCRIPT).$(LIBVER_PATCH_SCRIPT)
+LIBVER_MAJOR := $(shell echo $(LIBVER_MAJOR_SCRIPT))
+LIBVER_MINOR := $(shell echo $(LIBVER_MINOR_SCRIPT))
+LIBVER_PATCH := $(shell echo $(LIBVER_PATCH_SCRIPT))
+LIBVER  := $(shell echo $(LIBVER_SCRIPT))
 
-DESTDIR?=
-PREFIX ?= /usr/local
-CFLAGS ?= -O3
-CFLAGS += -I. -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wcast-qual -Wstrict-prototypes -pedantic
+BUILD_STATIC:=yes
+
+CPPFLAGS+= -DXXH_NAMESPACE=LZ4_
+CFLAGS  ?= -O3
+DEBUGFLAGS:= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \
+           -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes -Wundef \
+           -Wpointer-arith -Wstrict-aliasing=1
+CFLAGS  += $(DEBUGFLAGS) $(MOREFLAGS)
+FLAGS    = $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
 
-LIBDIR?= $(PREFIX)/lib
-INCLUDEDIR=$(PREFIX)/include
 
 
 # OS X linker doesn't support -soname, and use different extension
@@ -52,7 +60,7 @@ ifeq ($(shell uname), Darwin)
 	SHARED_EXT = dylib
 	SHARED_EXT_MAJOR = $(LIBVER_MAJOR).$(SHARED_EXT)
 	SHARED_EXT_VER = $(LIBVER).$(SHARED_EXT)
-	SONAME_FLAGS = -install_name $(PREFIX)/lib/liblz4.$(SHARED_EXT_MAJOR) -compatibility_version $(LIBVER_MAJOR) -current_version $(LIBVER)
+	SONAME_FLAGS = -install_name $(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR) -compatibility_version $(LIBVER_MAJOR) -current_version $(LIBVER)
 else
 	SONAME_FLAGS = -Wl,-soname=liblz4.$(SHARED_EXT).$(LIBVER_MAJOR)
 	SHARED_EXT = so
@@ -60,58 +68,113 @@ else
 	SHARED_EXT_VER = $(SHARED_EXT).$(LIBVER)
 endif
 
-default: liblz4
+LIBLZ4 = liblz4.$(SHARED_EXT_VER)
 
-all: liblz4
+.PHONY: default
+default: lib-release
 
-liblz4: lz4.c lz4hc.c lz4frame.c xxhash.c
+lib-release: DEBUGFLAGS :=
+lib-release: lib
+
+lib: liblz4.a liblz4
+
+all: lib
+
+all32: CFLAGS+=-m32
+all32: all
+
+liblz4.a: *.c
+ifeq ($(BUILD_STATIC),yes)  # can be disabled on command line
 	@echo compiling static library
-	@$(CC) $(CPPFLAGS) $(CFLAGS) -fPIC -c $^
-	@$(AR) rcs liblz4.a lz4.o lz4hc.o lz4frame.o xxhash.o
+	@$(CC) $(CPPFLAGS) $(CFLAGS) -c $^
+	@$(AR) rcs $@ *.o
+endif
+
+$(LIBLZ4): *.c
 	@echo compiling dynamic library $(LIBVER)
-	@$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -shared $^ -fPIC $(SONAME_FLAGS) -o $@.$(SHARED_EXT_VER)
+ifneq (,$(filter Windows%,$(OS)))
+	@$(CC) $(FLAGS) -DLZ4_DLL_EXPORT=1 -shared $^ -o dll\$@.dll
+	dlltool -D dll\liblz4.dll -d dll\liblz4.def -l dll\liblz4.lib
+else
+	@$(CC) $(FLAGS) -shared $^ -fPIC -fvisibility=hidden $(SONAME_FLAGS) -o $@
 	@echo creating versioned links
-	@ln -sf $@.$(SHARED_EXT_VER) $@.$(SHARED_EXT_MAJOR)
-	@ln -sf $@.$(SHARED_EXT_VER) $@.$(SHARED_EXT)
+	@ln -sf $@ liblz4.$(SHARED_EXT_MAJOR)
+	@ln -sf $@ liblz4.$(SHARED_EXT)
+endif
+
+liblz4: $(LIBLZ4)
 
 clean:
-	@rm -f core *.o *.a *.$(SHARED_EXT) *.$(SHARED_EXT).* liblz4.pc
+	@$(RM) core *.o liblz4.pc dll/liblz4.dll dll/liblz4.lib
+	@$(RM) *.a *.$(SHARED_EXT) *.$(SHARED_EXT_MAJOR) *.$(SHARED_EXT_VER)
 	@echo Cleaning library completed
 
 
-#------------------------------------------------------------------------
-#make install is validated only for Linux, OSX, kFreeBSD and Hurd targets
-ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU))
+#-----------------------------------------------------------------------------
+# make install is validated only for Linux, OSX, BSD, Hurd and Solaris targets
+#-----------------------------------------------------------------------------
+ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD NetBSD DragonFly SunOS))
+
+DESTDIR     ?=
+# directory variables : GNU convention prefers lowercase
+# support both lower and uppercase (BSD), use uppercase in script
+prefix      ?= /usr/local
+PREFIX      ?= $(prefix)
+exec_prefix ?= $(PREFIX)
+libdir      ?= $(exec_prefix)/lib
+LIBDIR      ?= $(libdir)
+includedir  ?= $(PREFIX)/include
+INCLUDEDIR  ?= $(includedir)
+
+ifneq (,$(filter $(shell uname),OpenBSD FreeBSD NetBSD DragonFly))
+PKGCONFIGDIR ?= $(PREFIX)/libdata/pkgconfig
+else
+PKGCONFIGDIR ?= $(LIBDIR)/pkgconfig
+endif
+
+ifneq (,$(filter $(shell uname),SunOS))
+INSTALL ?= ginstall
+else
+INSTALL ?= install
+endif
+
+INSTALL_PROGRAM ?= $(INSTALL)
+INSTALL_DATA    ?= $(INSTALL) -m 644
 
 liblz4.pc: liblz4.pc.in Makefile
 	@echo creating pkgconfig
 	@sed -e 's|@PREFIX@|$(PREFIX)|' \
-            -e 's|@LIBDIR@|$(LIBDIR)|' \
-            -e 's|@INCLUDEDIR@|$(INCLUDEDIR)|' \
-            -e 's|@VERSION@|$(VERSION)|' \
-             $< >$@
+         -e 's|@LIBDIR@|$(LIBDIR)|' \
+         -e 's|@INCLUDEDIR@|$(INCLUDEDIR)|' \
+         -e 's|@VERSION@|$(LIBVER)|' \
+          $< >$@
 
-install: liblz4 liblz4.pc
-	@install -d -m 755 $(DESTDIR)$(LIBDIR)/pkgconfig/ $(DESTDIR)$(INCLUDEDIR)/
-	@install -m 755 liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER)
-	@cp -a liblz4.$(SHARED_EXT_MAJOR) $(DESTDIR)$(LIBDIR)
-	@cp -a liblz4.$(SHARED_EXT) $(DESTDIR)$(LIBDIR)
-	@cp -a liblz4.pc $(DESTDIR)$(LIBDIR)/pkgconfig/
-	@install -m 644 liblz4.a $(DESTDIR)$(LIBDIR)/liblz4.a
-	@install -m 644 lz4.h $(DESTDIR)$(INCLUDEDIR)/lz4.h
-	@install -m 644 lz4hc.h $(DESTDIR)$(INCLUDEDIR)/lz4hc.h
-	@install -m 644 lz4frame.h $(DESTDIR)$(INCLUDEDIR)/lz4frame.h
-	@echo lz4 static and shared library installed
+install: lib liblz4.pc
+	@$(INSTALL) -d -m 755 $(DESTDIR)$(PKGCONFIGDIR)/ $(DESTDIR)$(INCLUDEDIR)/ $(DESTDIR)$(LIBDIR)/
+	@$(INSTALL_DATA) liblz4.pc $(DESTDIR)$(PKGCONFIGDIR)/
+	@echo Installing libraries
+ifeq ($(BUILD_STATIC),yes)
+	@$(INSTALL_DATA) liblz4.a $(DESTDIR)$(LIBDIR)/liblz4.a
+	@$(INSTALL_DATA) lz4frame_static.h $(DESTDIR)$(INCLUDEDIR)/lz4frame_static.h
+endif
+	@$(INSTALL_PROGRAM) liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)
+	@ln -sf liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR)
+	@ln -sf liblz4.$(SHARED_EXT_VER) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT)
+	@echo Installing headers in $(INCLUDEDIR)
+	@$(INSTALL_DATA) lz4.h $(DESTDIR)$(INCLUDEDIR)/lz4.h
+	@$(INSTALL_DATA) lz4hc.h $(DESTDIR)$(INCLUDEDIR)/lz4hc.h
+	@$(INSTALL_DATA) lz4frame.h $(DESTDIR)$(INCLUDEDIR)/lz4frame.h
+	@echo lz4 libraries installed
 
 uninstall:
-	@rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT)
-	@rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR)
-	@rm -f $(DESTDIR)$(LIBDIR)/pkgconfig/liblz4.pc
-	@[ -x $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER) ] && rm -f $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER)
-	@[ -f $(DESTDIR)$(LIBDIR)/liblz4.a ] && rm -f $(DESTDIR)$(LIBDIR)/liblz4.a
-	@[ -f $(DESTDIR)$(INCLUDEDIR)/lz4.h ] && rm -f $(DESTDIR)$(INCLUDEDIR)/lz4.h
-	@[ -f $(DESTDIR)$(INCLUDEDIR)/lz4hc.h ] && rm -f $(DESTDIR)$(INCLUDEDIR)/lz4hc.h
-	@[ -f $(DESTDIR)$(INCLUDEDIR)/lz4frame.h ] && rm -f $(DESTDIR)$(INCLUDEDIR)/lz4frame.h
+	@$(RM) $(DESTDIR)$(LIBDIR)/pkgconfig/liblz4.pc
+	@$(RM) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT)
+	@$(RM) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_MAJOR)
+	@$(RM) $(DESTDIR)$(LIBDIR)/liblz4.$(SHARED_EXT_VER)
+	@$(RM) $(DESTDIR)$(LIBDIR)/liblz4.a
+	@$(RM) $(DESTDIR)$(INCLUDEDIR)/lz4.h
+	@$(RM) $(DESTDIR)$(INCLUDEDIR)/lz4hc.h
+	@$(RM) $(DESTDIR)$(INCLUDEDIR)/lz4frame.h
 	@echo lz4 libraries successfully uninstalled
 
 endif

src/lz4/lib/README.md

@@ -1,19 +1,73 @@
 LZ4 - Library Files
 ================================
 
-This directory contains many files, but you don't necessarily need them all.
+The directory contains many files, but depending on project's objectives,
+not all of them are necessary.
 
-If you want to integrate LZ4 compression/decompression into your program, you basically need to include "**lz4.c**" and "**lz4.h**" only.
+#### Minimal LZ4 build
 
-If you want more compression, at the cost of compression speed (but preserving decompression speed), you will also have to include "**lz4hc.c**" and "**lz4hc.h**". Note that lz4hc needs lz4 to work properly.
+The minimum required is **`lz4.c`** and **`lz4.h`**,
+which will provide the fast compression and decompression algorithm.
 
-Next level, if you want to produce files or data streams compatible with lz4 utility, you will have to use and include "**lz4frame.c**" and **lz4frame.h**". This library encapsulate lz4-compressed blocks into the official interoperable frame format. In order to work properly, lz4frame needs lz4 and lz4hc, and also "**xxhash.c**" and "**xxhash.h**", which provide the error detection algorithm.
 
-A more complex "lz4frame_static.h" is also provided, although its usage is not recommended. It contains definitions which are not guaranteed to remain stable within future versions. Use only if you don't plan to update your lz4 version.
+#### The High Compression variant of LZ4
 
-The other files are not source code. There are :
+For more compression at the cost of compression speed,
+the High Compression variant **lz4hc** is available.
+It's necessary to add **`lz4hc.c`** and **`lz4hc.h`**.
+The variant still depends on regular `lz4` source files.
+In particular, the decompression is still provided by `lz4.c`.
+
+
+#### Compatibility issues
+
+In order to produce files or streams compatible with `lz4` command line utility,
+it's necessary to encode lz4-compressed blocks using the [official interoperable frame format].
+This format is generated and decoded automatically by the **lz4frame** library.
+In order to work properly, lz4frame needs lz4 and lz4hc, and also **xxhash**,
+which provides error detection.
+(_Advanced stuff_ : It's possible to hide xxhash symbols into a local namespace.
+This is what `liblz4` does, to avoid symbol duplication
+in case a user program would link to several libraries containing xxhash symbols.)
+
+
+#### Advanced API 
+
+A more complex `lz4frame_static.h` is also provided.
+It contains definitions which are not guaranteed to remain stable within future versions.
+It must be used with static linking ***only***.
+
+
+#### Using MinGW+MSYS to create DLL
+
+DLL can be created using MinGW+MSYS with the `make liblz4` command.
+This command creates `dll\liblz4.dll` and the import library `dll\liblz4.lib`.
+The import library is only required with Visual C++.
+The header files `lz4.h`, `lz4hc.h`, `lz4frame.h` and the dynamic library
+`dll\liblz4.dll` are required to compile a project using gcc/MinGW.
+The dynamic library has to be added to linking options.
+It means that if a project that uses LZ4 consists of a single `test-dll.c`
+file it should be linked with `dll\liblz4.dll`. For example:
+```
+    gcc $(CFLAGS) -Iinclude/ test-dll.c -o test-dll dll\liblz4.dll
+```
+The compiled executable will require LZ4 DLL which is available at `dll\liblz4.dll`. 
+
+
+#### Miscellaneous 
+
+Other files present in the directory are not source code. There are :
 
  - LICENSE : contains the BSD license text
  - Makefile : script to compile or install lz4 library (static or dynamic)
  - liblz4.pc.in : for pkg-config (make install)
+ - README.md : this file
 
+[official interoperable frame format]: ../doc/lz4_Frame_format.md
+
+
+#### License 
+
+All source material within __lib__ directory are BSD 2-Clause licensed.
+See [LICENSE](LICENSE) for details.
+The license is also repeated at the top of each source file.

src/lz4/lib/dll/example/Makefile

@@ -0,0 +1,63 @@
+# ##########################################################################
+# LZ4 programs - Makefile
+# Copyright (C) Yann Collet 2016
+#
+# GPL v2 License
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# You can contact the author at :
+#  - LZ4 homepage : http://www.lz4.org
+#  - LZ4 source repository : https://github.com/lz4/lz4
+# ##########################################################################
+
+VOID    := /dev/null
+LZ4DIR  := ../include
+LIBDIR  := ../static
+DLLDIR  := ../dll
+
+CFLAGS  ?= -O3   # can select custom flags. For example : CFLAGS="-O2 -g" make
+CFLAGS  += -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow -Wswitch-enum \
+           -Wdeclaration-after-statement -Wstrict-prototypes \
+           -Wpointer-arith -Wstrict-aliasing=1
+CFLAGS  += $(MOREFLAGS)
+CPPFLAGS:= -I$(LZ4DIR) -DXXH_NAMESPACE=LZ4_
+FLAGS   := $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)
+
+
+# Define *.exe as extension for Windows systems
+ifneq (,$(filter Windows%,$(OS)))
+EXT =.exe
+else
+EXT =
+endif
+
+.PHONY: default fullbench-dll fullbench-lib
+
+
+default: all
+
+all: fullbench-dll fullbench-lib
+
+
+fullbench-lib: fullbench.c xxhash.c
+	$(CC) $(FLAGS) $^ -o $@$(EXT) $(LIBDIR)/liblz4_static.lib
+
+fullbench-dll: fullbench.c xxhash.c
+	$(CC) $(FLAGS) $^ -o $@$(EXT) -DLZ4_DLL_IMPORT=1 $(DLLDIR)/liblz4.dll
+
+clean:
+	@$(RM) fullbench-dll$(EXT) fullbench-lib$(EXT) \
+	@echo Cleaning completed

src/lz4/lib/dll/example/README.md

@@ -0,0 +1,69 @@
+LZ4 Windows binary package
+====================================
+
+#### The package contents
+
+- `lz4.exe`                  : Command Line Utility, supporting gzip-like arguments
+- `dll\liblz4.dll`           : The DLL of LZ4 library
+- `dll\liblz4.lib`           : The import library of LZ4 library for Visual C++
+- `example\`                 : The example of usage of LZ4 library
+- `include\`                 : Header files required with LZ4 library
+- `static\liblz4_static.lib` : The static LZ4 library
+
+
+#### Usage of Command Line Interface
+
+Command Line Interface (CLI) supports gzip-like arguments.
+By default CLI takes an input file and compresses it to an output file:
+```
+    Usage: lz4 [arg] [input] [output]
+```
+The full list of commands for CLI can be obtained with `-h` or `-H`. The ratio can
+be improved with commands from `-3` to `-16` but higher levels also have slower
+compression. CLI includes in-memory compression benchmark module with compression
+levels starting from `-b` and ending with `-e` with iteration time of `-i` seconds.
+CLI supports aggregation of parameters i.e. `-b1`, `-e18`, and `-i1` can be joined
+into `-b1e18i1`.
+
+
+#### The example of usage of static and dynamic LZ4 libraries with gcc/MinGW
+
+Use `cd example` and `make` to build `fullbench-dll` and `fullbench-lib`.
+`fullbench-dll` uses a dynamic LZ4 library from the `dll` directory.
+`fullbench-lib` uses a static LZ4 library from the `lib` directory.
+
+
+#### Using LZ4 DLL with gcc/MinGW
+
+The header files from `include\` and the dynamic library `dll\liblz4.dll`
+are required to compile a project using gcc/MinGW.
+The dynamic library has to be added to linking options.
+It means that if a project that uses LZ4 consists of a single `test-dll.c`
+file it should be linked with `dll\liblz4.dll`. For example:
+```
+    gcc $(CFLAGS) -Iinclude\ test-dll.c -o test-dll dll\liblz4.dll
+```
+The compiled executable will require LZ4 DLL which is available at `dll\liblz4.dll`.
+
+
+#### The example of usage of static and dynamic LZ4 libraries with Visual C++
+
+Open `example\fullbench-dll.sln` to compile `fullbench-dll` that uses a
+dynamic LZ4 library from the `dll` directory. The solution works with Visual C++
+2010 or newer. When one will open the solution with Visual C++ newer than 2010
+then the solution will upgraded to the current version.
+
+
+#### Using LZ4 DLL with Visual C++
+
+The header files from `include\` and the import library `dll\liblz4.lib`
+are required to compile a project using Visual C++.
+
+1. The header files should be added to `Additional Include Directories` that can
+   be found in project properties `C/C++` then `General`.
+2. The import library has to be added to `Additional Dependencies` that can
+   be found in project properties `Linker` then `Input`.
+   If one will provide only the name `liblz4.lib` without a full path to the library
+   the directory has to be added to `Linker\General\Additional Library Directories`.
+
+The compiled executable will require LZ4 DLL which is available at `dll\liblz4.dll`.

src/lz4/lib/dll/example/fullbench-dll.sln

@@ -0,0 +1,25 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Express 2012 for Windows Desktop
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fullbench-dll", "fullbench-dll.vcxproj", "{13992FD2-077E-4954-B065-A428198201A9}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Debug|x64 = Debug|x64
+		Release|Win32 = Release|Win32
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{13992FD2-077E-4954-B065-A428198201A9}.Debug|Win32.ActiveCfg = Debug|Win32
+		{13992FD2-077E-4954-B065-A428198201A9}.Debug|Win32.Build.0 = Debug|Win32
+		{13992FD2-077E-4954-B065-A428198201A9}.Debug|x64.ActiveCfg = Debug|x64
+		{13992FD2-077E-4954-B065-A428198201A9}.Debug|x64.Build.0 = Debug|x64
+		{13992FD2-077E-4954-B065-A428198201A9}.Release|Win32.ActiveCfg = Release|Win32
+		{13992FD2-077E-4954-B065-A428198201A9}.Release|Win32.Build.0 = Release|Win32
+		{13992FD2-077E-4954-B065-A428198201A9}.Release|x64.ActiveCfg = Release|x64
+		{13992FD2-077E-4954-B065-A428198201A9}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

src/lz4/lib/dll/example/fullbench-dll.vcxproj

@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{13992FD2-077E-4954-B065-A428198201A9}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>fullbench-dll</RootNamespace>
+    <OutDir>$(SolutionDir)bin\$(Platform)_$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)bin\obj\$(RootNamespace)_$(Platform)_$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(IncludePath);$(UniversalCRT_IncludePath);$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>$(IncludePath);$(UniversalCRT_IncludePath);$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+    <RunCodeAnalysis>true</RunCodeAnalysis>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(IncludePath);$(UniversalCRT_IncludePath);$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>$(IncludePath);$(UniversalCRT_IncludePath);$(SolutionDir)..\..\lib;$(VCInstallDir)include;$(VCInstallDir)atlmfc\include;$(WindowsSDK_IncludePath);</IncludePath>
+    <RunCodeAnalysis>true</RunCodeAnalysis>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;LZ4_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <EnablePREfast>false</EnablePREfast>
+      <AdditionalIncludeDirectories>..\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(SolutionDir)..\dll;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>liblz4.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;LZ4_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>true</TreatWarningAsError>
+      <EnablePREfast>true</EnablePREfast>
+      <AdditionalOptions>/analyze:stacksize295252 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>..\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(SolutionDir)..\dll;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>liblz4.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;LZ4_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>false</TreatWarningAsError>
+      <EnablePREfast>false</EnablePREfast>
+      <AdditionalIncludeDirectories>..\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalLibraryDirectories>$(SolutionDir)..\dll;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>liblz4.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;LZ4_DLL_IMPORT=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <TreatWarningAsError>false</TreatWarningAsError>
+      <EnablePREfast>true</EnablePREfast>
+      <AdditionalOptions>/analyze:stacksize295252 %(AdditionalOptions)</AdditionalOptions>
+      <AdditionalIncludeDirectories>..\include</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalLibraryDirectories>$(SolutionDir)..\dll;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>liblz4.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="xxhash.c" />
+    <ClCompile Include="fullbench.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\lz4.h" />
+    <ClInclude Include="..\include\lz4frame.h" />
+    <ClInclude Include="..\include\lz4hc.h" />
+    <ClInclude Include="xxhash.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

src/lz4/lib/dll/liblz4.def

@@ -0,0 +1,62 @@
+LIBRARY liblz4.dll
+EXPORTS
+    LZ4F_compressBegin
+    LZ4F_compressBound
+    LZ4F_compressEnd
+    LZ4F_compressFrame
+    LZ4F_compressFrameBound
+    LZ4F_compressUpdate
+    LZ4F_createCompressionContext
+    LZ4F_createDecompressionContext
+    LZ4F_decompress
+    LZ4F_flush
+    LZ4F_freeCompressionContext
+    LZ4F_freeDecompressionContext
+    LZ4F_getErrorName
+    LZ4F_getFrameInfo
+    LZ4F_getVersion
+    LZ4F_isError
+    LZ4_compress
+    LZ4_compressBound
+    LZ4_compressHC
+    LZ4_compressHC_continue
+    LZ4_compressHC_limitedOutput
+    LZ4_compressHC_limitedOutput_continue
+    LZ4_compressHC_limitedOutput_withStateHC
+    LZ4_compressHC_withStateHC
+    LZ4_compress_HC
+    LZ4_compress_HC_continue
+    LZ4_compress_HC_extStateHC
+    LZ4_compress_continue
+    LZ4_compress_default
+    LZ4_compress_destSize
+    LZ4_compress_fast
+    LZ4_compress_fast_continue
+    LZ4_compress_fast_extState
+    LZ4_compress_limitedOutput
+    LZ4_compress_limitedOutput_continue
+    LZ4_compress_limitedOutput_withState
+    LZ4_compress_withState
+    LZ4_createStream
+    LZ4_createStreamDecode
+    LZ4_createStreamHC
+    LZ4_decompress_fast
+    LZ4_decompress_fast_continue
+    LZ4_decompress_fast_usingDict
+    LZ4_decompress_safe
+    LZ4_decompress_safe_continue
+    LZ4_decompress_safe_partial
+    LZ4_decompress_safe_usingDict
+    LZ4_freeStream
+    LZ4_freeStreamDecode
+    LZ4_freeStreamHC
+    LZ4_loadDict
+    LZ4_loadDictHC
+    LZ4_resetStream
+    LZ4_resetStreamHC
+    LZ4_saveDict
+    LZ4_saveDictHC
+    LZ4_setStreamDecode
+    LZ4_sizeofState
+    LZ4_sizeofStateHC
+    LZ4_versionNumber

src/lz4/lib/liblz4.pc.in

@@ -7,8 +7,8 @@ libdir=@LIBDIR@
 includedir=@INCLUDEDIR@
 
 Name: lz4
-Description: fast lossless compression algorithm library
-URL: http://code.google.com/p/lz4/
+Description: extremely fast lossless compression algorithm library
+URL: http://www.lz4.org/
 Version: @VERSION@
 Libs: -L@LIBDIR@ -llz4
 Cflags: -I@INCLUDEDIR@

src/lz4/lib/lz4.h

@@ -1,7 +1,7 @@
 /*
-   LZ4 - Fast LZ compression algorithm
-   Header File
-   Copyright (C) 2011-2015, Yann Collet.
+ *  LZ4 - Fast LZ compression algorithm
+ *  Header File
+ *  Copyright (C) 2011-2017, Yann Collet.
 
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
@@ -29,52 +29,97 @@
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    You can contact the author at :
-   - LZ4 source repository : https://github.com/Cyan4973/lz4
-   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+    - LZ4 homepage : http://www.lz4.org
+    - LZ4 source repository : https://github.com/lz4/lz4
 */
-#pragma once
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
-/*
- * lz4.h provides block compression functions, and gives full buffer control to programmer.
- * If you need to generate inter-operable compressed data (respecting LZ4 frame specification),
- * and can let the library handle its own memory, please use lz4frame.h instead.
+#ifndef LZ4_H_2983827168210
+#define LZ4_H_2983827168210
+
+/* --- Dependency --- */
+#include <stddef.h>   /* size_t */
+
+
+/**
+  Introduction
+
+  LZ4 is lossless compression algorithm, providing compression speed at 400 MB/s per core,
+  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
+  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
+
+  The LZ4 compression library provides in-memory compression and decompression functions.
+  Compression can be done in:
+    - a single step (described as Simple Functions)
+    - a single step, reusing a context (described in Advanced Functions)
+    - unbounded multiple steps (described as Streaming compression)
+
+  lz4.h provides block compression functions. It gives full buffer control to user.
+  Decompressing an lz4-compressed block also requires metadata (such as compressed size).
+  Each application is free to encode such metadata in whichever way it wants.
+
+  An additional format, called LZ4 frame specification (doc/lz4_Frame_format.md),
+  take care of encoding standard metadata alongside LZ4-compressed blocks.
+  If your application requires interoperability, it's recommended to use it.
+  A library is provided to take care of it, see lz4frame.h.
 */
 
-/**************************************
-*  Version
-**************************************/
-#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
-#define LZ4_VERSION_MINOR    7    /* for new (non-breaking) interface capabilities */
-#define LZ4_VERSION_RELEASE  0    /* for tweaks, bug-fixes, or development */
-#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
-int LZ4_versionNumber (void);
+/*^***************************************************************
+*  Export parameters
+*****************************************************************/
+/*
+*  LZ4_DLL_EXPORT :
+*  Enable exporting of functions when building a Windows DLL
+*  LZ4LIB_API :
+*  Control library symbols visibility.
+*/
+#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
+#  define LZ4LIB_API __declspec(dllexport)
+#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
+#  define LZ4LIB_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+#  define LZ4LIB_API __attribute__ ((__visibility__ ("default")))
+#else
+#  define LZ4LIB_API
+#endif
 
-/**************************************
+
+/*------   Version   ------*/
+#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
+#define LZ4_VERSION_MINOR    8    /* for new (non-breaking) interface capabilities */
+#define LZ4_VERSION_RELEASE  0    /* for tweaks, bug-fixes, or development */
+
+#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
+
+#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
+#define LZ4_QUOTE(str) #str
+#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
+#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)
+
+LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; to be used when checking dll version */
+LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; to be used when checking dll version */
+
+
+/*-************************************
 *  Tuning parameter
 **************************************/
-/*
+/*!
  * LZ4_MEMORY_USAGE :
  * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
  * Increasing memory usage improves compression ratio
  * Reduced memory usage can improve speed, due to cache effect
  * Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
  */
-#define LZ4_MEMORY_USAGE 14
+#ifndef LZ4_MEMORY_USAGE
+# define LZ4_MEMORY_USAGE 14
+#endif
 
-
-/**************************************
+/*-************************************
 *  Simple Functions
 **************************************/
-
-int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
-int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
-
-/*
-LZ4_compress_default() :
+/*! LZ4_compress_default() :
     Compresses 'sourceSize' bytes from buffer 'source'
     into already allocated 'dest' buffer of size 'maxDestSize'.
     Compression is guaranteed to succeed if 'maxDestSize' >= LZ4_compressBound(sourceSize).
@@ -86,9 +131,10 @@ LZ4_compress_default() :
         sourceSize  : Max supported value is LZ4_MAX_INPUT_VALUE
         maxDestSize : full or partial size of buffer 'dest' (which must be already allocated)
         return : the number of bytes written into buffer 'dest' (necessarily <= maxOutputSize)
-              or 0 if compression fails
+              or 0 if compression fails */
+LZ4LIB_API int LZ4_compress_default(const char* source, char* dest, int sourceSize, int maxDestSize);
 
-LZ4_decompress_safe() :
+/*! LZ4_decompress_safe() :
     compressedSize : is the precise full size of the compressed block.
     maxDecompressedSize : is the size of destination buffer, which must be already allocated.
     return : the number of bytes decompressed into destination buffer (necessarily <= maxDecompressedSize)
@@ -97,15 +143,16 @@ LZ4_decompress_safe() :
              This function is protected against buffer overflow exploits, including malicious data packets.
              It never writes outside output buffer, nor reads outside input buffer.
 */
+LZ4LIB_API int LZ4_decompress_safe (const char* source, char* dest, int compressedSize, int maxDecompressedSize);
 
 
-/**************************************
+/*-************************************
 *  Advanced Functions
 **************************************/
 #define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
 #define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
 
-/*
+/*!
 LZ4_compressBound() :
     Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
     This function is primarily useful for memory allocation purposes (destination buffer size).
@@ -115,9 +162,9 @@ LZ4_compressBound() :
         return : maximum output size in a "worst case" scenario
               or 0, if input size is too large ( > LZ4_MAX_INPUT_SIZE)
 */
-int LZ4_compressBound(int inputSize);
+LZ4LIB_API int LZ4_compressBound(int inputSize);
 
-/*
+/*!
 LZ4_compress_fast() :
     Same as LZ4_compress_default(), but allows to select an "acceleration" factor.
     The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
@@ -125,21 +172,21 @@ LZ4_compress_fast() :
     An acceleration value of "1" is the same as regular LZ4_compress_default()
     Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1.
 */
-int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
+LZ4LIB_API int LZ4_compress_fast (const char* source, char* dest, int sourceSize, int maxDestSize, int acceleration);
 
 
-/*
+/*!
 LZ4_compress_fast_extState() :
     Same compression function, just using an externally allocated memory space to store compression state.
     Use LZ4_sizeofState() to know how much memory must be allocated,
     and allocate it on 8-bytes boundaries (using malloc() typically).
     Then, provide it as 'void* state' to compression function.
 */
-int LZ4_sizeofState(void);
-int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
+LZ4LIB_API int LZ4_sizeofState(void);
+LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* source, char* dest, int inputSize, int maxDestSize, int acceleration);
 
 
-/*
+/*!
 LZ4_compress_destSize() :
     Reverse the logic, by compressing as much data as possible from 'source' buffer
     into already allocated buffer 'dest' of size 'targetDestSize'.
@@ -150,10 +197,10 @@ LZ4_compress_destSize() :
         return : Nb bytes written into 'dest' (necessarily <= targetDestSize)
               or 0 if compression fails
 */
-int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
+LZ4LIB_API int LZ4_compress_destSize (const char* source, char* dest, int* sourceSizePtr, int targetDestSize);
 
 
-/*
+/*!
 LZ4_decompress_fast() :
     originalSize : is the original and therefore uncompressed size
     return : the number of bytes read from the source buffer (in other words, the compressed size)
@@ -164,9 +211,9 @@ LZ4_decompress_fast() :
            However, it does not provide any protection against intentionally modified data stream (malicious input).
            Use this function in trusted environment only (data to decode comes from a trusted source).
 */
-int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
+LZ4LIB_API int LZ4_decompress_fast (const char* source, char* dest, int originalSize);
 
-/*
+/*!
 LZ4_decompress_safe_partial() :
     This function decompress a compressed block of size 'compressedSize' at position 'source'
     into destination buffer 'dest' of size 'maxDecompressedSize'.
@@ -178,142 +225,203 @@ LZ4_decompress_safe_partial() :
              If the source stream is detected malformed, the function will stop decoding and return a negative result.
              This function never writes outside of output buffer, and never reads outside of input buffer. It is therefore protected against malicious data packets
 */
-int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
+LZ4LIB_API int LZ4_decompress_safe_partial (const char* source, char* dest, int compressedSize, int targetOutputSize, int maxDecompressedSize);
 
 
-/***********************************************
+/*-*********************************************
 *  Streaming Compression Functions
 ***********************************************/
-#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
-#define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(long long))
-/*
- * LZ4_stream_t
- * information structure to track an LZ4 stream.
- * important : init this structure content before first use !
- * note : only allocated directly the structure if you are statically linking LZ4
- *        If you are using liblz4 as a DLL, please use below construction methods instead.
+typedef union LZ4_stream_u LZ4_stream_t;   /* incomplete type (defined later) */
+
+/*! LZ4_createStream() and LZ4_freeStream() :
+ *  LZ4_createStream() will allocate and initialize an `LZ4_stream_t` structure.
+ *  LZ4_freeStream() releases its memory.
  */
-typedef struct { long long table[LZ4_STREAMSIZE_U64]; } LZ4_stream_t;
+LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
+LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
 
-/*
- * LZ4_resetStream
- * Use this function to init an allocated LZ4_stream_t structure
+/*! LZ4_resetStream() :
+ *  An LZ4_stream_t structure can be allocated once and re-used multiple times.
+ *  Use this function to init an allocated `LZ4_stream_t` structure and start a new compression.
  */
-void LZ4_resetStream (LZ4_stream_t* streamPtr);
+LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
 
-/*
- * LZ4_createStream will allocate and initialize an LZ4_stream_t structure
- * LZ4_freeStream releases its memory.
- * In the context of a DLL (liblz4), please use these methods rather than the static struct.
- * They are more future proof, in case of a change of LZ4_stream_t size.
+/*! LZ4_loadDict() :
+ *  Use this function to load a static dictionary into LZ4_stream.
+ *  Any previous data will be forgotten, only 'dictionary' will remain in memory.
+ *  Loading a size of 0 is allowed.
+ *  Return : dictionary size, in bytes (necessarily <= 64 KB)
  */
-LZ4_stream_t* LZ4_createStream(void);
-int           LZ4_freeStream (LZ4_stream_t* streamPtr);
+LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
 
-/*
- * LZ4_loadDict
- * Use this function to load a static dictionary into LZ4_stream.
- * Any previous data will be forgotten, only 'dictionary' will remain in memory.
- * Loading a size of 0 is allowed.
- * Return : dictionary size, in bytes (necessarily <= 64 KB)
+/*! LZ4_compress_fast_continue() :
+ *  Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
+ *  Important : Previous data blocks are assumed to remain present and unmodified !
+ *  'dst' buffer must be already allocated.
+ *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
+ *  If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function @return==0.
+ *  After an error, the stream status is invalid, it can only be reset or freed.
  */
-int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
+LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
 
-/*
- * LZ4_compress_fast_continue
- * Compress buffer content 'src', using data from previously compressed blocks as dictionary to improve compression ratio.
- * Important : Previous data blocks are assumed to still be present and unmodified !
- * 'dst' buffer must be already allocated.
- * If maxDstSize >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
- * If not, and if compressed data cannot fit into 'dst' buffer size, compression stops, and function returns a zero.
+/*! LZ4_saveDict() :
+ *  If previously compressed data block is not guaranteed to remain available at its current memory location,
+ *  save it into a safer place (char* safeBuffer).
+ *  Note : it's not necessary to call LZ4_loadDict() after LZ4_saveDict(), dictionary is immediately usable.
+ *  @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
  */
-int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int maxDstSize, int acceleration);
-
-/*
- * LZ4_saveDict
- * If previously compressed data block is not guaranteed to remain available at its memory location
- * save it into a safer place (char* safeBuffer)
- * Note : you don't need to call LZ4_loadDict() afterwards,
- *        dictionary is immediately usable, you can therefore call LZ4_compress_fast_continue()
- * Return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error
- */
-int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
+LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int dictSize);
 
 
-/************************************************
+/*-**********************************************
 *  Streaming Decompression Functions
+*  Bufferless synchronous API
 ************************************************/
+typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* incomplete type (defined later) */
 
+/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
+ *  creation / destruction of streaming decompression tracking structure */
+LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
+LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
+
+/*! LZ4_setStreamDecode() :
+ *  Use this function to instruct where to find the dictionary.
+ *  Setting a size of 0 is allowed (same effect as reset).
+ *  @return : 1 if OK, 0 if error
+ */
+LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
+
+/*! LZ4_decompress_*_continue() :
+ *  These decoding functions allow decompression of multiple blocks in "streaming" mode.
+ *  Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
+ *  In the case of a ring buffers, decoding buffer must be either :
+ *  - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
+ *    In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
+ *  - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
+ *    maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
+ *    In which case, encoding and decoding buffers do not need to be synchronized,
+ *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
+ *  - _At least_ 64 KB + 8 bytes + maxBlockSize.
+ *    In which case, encoding and decoding buffers do not need to be synchronized,
+ *    and encoding ring buffer can have any size, including larger than decoding buffer.
+ *  Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
+ *  and indicate where it is saved using LZ4_setStreamDecode()
+*/
+LZ4LIB_API int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
+LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
+
+
+/*! LZ4_decompress_*_usingDict() :
+ *  These decoding functions work the same as
+ *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_*_continue()
+ *  They are stand-alone, and don't need an LZ4_streamDecode_t structure.
+ */
+LZ4LIB_API int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
+LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
+
+
+/*^**********************************************
+ * !!!!!!   STATIC LINKING ONLY   !!!!!!
+ ***********************************************/
+/*-************************************
+ *  Private definitions
+ **************************************
+ * Do not use these definitions.
+ * They are exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
+ * Using these definitions will expose code to API and/or ABI break in future versions of the library.
+ **************************************/
+#define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
+#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
+#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
+
+#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#include <stdint.h>
+
+typedef struct {
+    uint32_t hashTable[LZ4_HASH_SIZE_U32];
+    uint32_t currentOffset;
+    uint32_t initCheck;
+    const uint8_t* dictionary;
+    uint8_t* bufferStart;   /* obsolete, used for slideInputBuffer */
+    uint32_t dictSize;
+} LZ4_stream_t_internal;
+
+typedef struct {
+    const uint8_t* externalDict;
+    size_t extDictSize;
+    const uint8_t* prefixEnd;
+    size_t prefixSize;
+} LZ4_streamDecode_t_internal;
+
+#else
+
+typedef struct {
+    unsigned int hashTable[LZ4_HASH_SIZE_U32];
+    unsigned int currentOffset;
+    unsigned int initCheck;
+    const unsigned char* dictionary;
+    unsigned char* bufferStart;   /* obsolete, used for slideInputBuffer */
+    unsigned int dictSize;
+} LZ4_stream_t_internal;
+
+typedef struct {
+    const unsigned char* externalDict;
+    size_t extDictSize;
+    const unsigned char* prefixEnd;
+    size_t prefixSize;
+} LZ4_streamDecode_t_internal;
+
+#endif
+
+/*!
+ * LZ4_stream_t :
+ * information structure to track an LZ4 stream.
+ * init this structure before first use.
+ * note : only use in association with static linking !
+ *        this definition is not API/ABI safe,
+ *        it may change in a future version !
+ */
+#define LZ4_STREAMSIZE_U64 ((1 << (LZ4_MEMORY_USAGE-3)) + 4)
+#define LZ4_STREAMSIZE     (LZ4_STREAMSIZE_U64 * sizeof(unsigned long long))
+union LZ4_stream_u {
+    unsigned long long table[LZ4_STREAMSIZE_U64];
+    LZ4_stream_t_internal internal_donotuse;
+} ;  /* previously typedef'd to LZ4_stream_t */
+
+
+/*!
+ * LZ4_streamDecode_t :
+ * information structure to track an LZ4 stream during decompression.
+ * init this structure  using LZ4_setStreamDecode (or memset()) before first use
+ * note : only use in association with static linking !
+ *        this definition is not API/ABI safe,
+ *        and may change in a future version !
+ */
 #define LZ4_STREAMDECODESIZE_U64  4
 #define LZ4_STREAMDECODESIZE     (LZ4_STREAMDECODESIZE_U64 * sizeof(unsigned long long))
-typedef struct { unsigned long long table[LZ4_STREAMDECODESIZE_U64]; } LZ4_streamDecode_t;
-/*
- * LZ4_streamDecode_t
- * information structure to track an LZ4 stream.
- * init this structure content using LZ4_setStreamDecode or memset() before first use !
- *
- * In the context of a DLL (liblz4) please prefer usage of construction methods below.
- * They are more future proof, in case of a change of LZ4_streamDecode_t size in the future.
- * LZ4_createStreamDecode will allocate and initialize an LZ4_streamDecode_t structure
- * LZ4_freeStreamDecode releases its memory.
- */
-LZ4_streamDecode_t* LZ4_createStreamDecode(void);
-int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
-
-/*
- * LZ4_setStreamDecode
- * Use this function to instruct where to find the dictionary.
- * Setting a size of 0 is allowed (same effect as reset).
- * Return : 1 if OK, 0 if error
- */
-int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
-
-/*
-*_continue() :
-    These decoding functions allow decompression of multiple blocks in "streaming" mode.
-    Previously decoded blocks *must* remain available at the memory position where they were decoded (up to 64 KB)
-    In the case of a ring buffers, decoding buffer must be either :
-    - Exactly same size as encoding buffer, with same update rule (block boundaries at same positions)
-      In which case, the decoding & encoding ring buffer can have any size, including very small ones ( < 64 KB).
-    - Larger than encoding buffer, by a minimum of maxBlockSize more bytes.
-      maxBlockSize is implementation dependent. It's the maximum size you intend to compress into a single block.
-      In which case, encoding and decoding buffers do not need to be synchronized,
-      and encoding ring buffer can have any size, including small ones ( < 64 KB).
-    - _At least_ 64 KB + 8 bytes + maxBlockSize.
-      In which case, encoding and decoding buffers do not need to be synchronized,
-      and encoding ring buffer can have any size, including larger than decoding buffer.
-    Whenever these conditions are not possible, save the last 64KB of decoded data into a safe buffer,
-    and indicate where it is saved using LZ4_setStreamDecode()
-*/
-int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxDecompressedSize);
-int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int originalSize);
+union LZ4_streamDecode_u {
+    unsigned long long table[LZ4_STREAMDECODESIZE_U64];
+    LZ4_streamDecode_t_internal internal_donotuse;
+} ;   /* previously typedef'd to LZ4_streamDecode_t */
 
 
-/*
-Advanced decoding functions :
-*_usingDict() :
-    These decoding functions work the same as
-    a combination of LZ4_setStreamDecode() followed by LZ4_decompress_x_continue()
-    They are stand-alone. They don't need nor update an LZ4_streamDecode_t structure.
-*/
-int LZ4_decompress_safe_usingDict (const char* source, char* dest, int compressedSize, int maxDecompressedSize, const char* dictStart, int dictSize);
-int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalSize, const char* dictStart, int dictSize);
-
-
-
-/**************************************
+/*-************************************
 *  Obsolete Functions
 **************************************/
-/* Deprecate Warnings */
-/* Should these warnings messages be a problem,
+
+/*! Deprecation warnings
+   Should deprecation warnings be a problem,
    it is generally possible to disable them,
-   with -Wno-deprecated-declarations for gcc
-   or _CRT_SECURE_NO_WARNINGS in Visual for example.
-   You can also define LZ4_DEPRECATE_WARNING_DEFBLOCK. */
-#ifndef LZ4_DEPRECATE_WARNING_DEFBLOCK
-#  define LZ4_DEPRECATE_WARNING_DEFBLOCK
+   typically with -Wno-deprecated-declarations for gcc
+   or _CRT_SECURE_NO_WARNINGS in Visual.
+   Otherwise, it's also possible to define LZ4_DISABLE_DEPRECATE_WARNINGS */
+#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
+#  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
+#else
 #  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  if (LZ4_GCC_VERSION >= 405) || defined(__clang__)
+#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
+#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
+#  elif (LZ4_GCC_VERSION >= 405) || defined(__clang__)
 #    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
 #  elif (LZ4_GCC_VERSION >= 301)
 #    define LZ4_DEPRECATED(message) __attribute__((deprecated))
@@ -323,36 +431,31 @@ int LZ4_decompress_fast_usingDict (const char* source, char* dest, int originalS
 #    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
 #    define LZ4_DEPRECATED(message)
 #  endif
-#endif /* LZ4_DEPRECATE_WARNING_DEFBLOCK */
+#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
 
 /* Obsolete compression functions */
-/* These functions are planned to start generate warnings by r131 approximately */
-int LZ4_compress               (const char* source, char* dest, int sourceSize);
-int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
-int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
-int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
-int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress               (const char* source, char* dest, int sourceSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_default() instead") int LZ4_compress_limitedOutput (const char* source, char* dest, int sourceSize, int maxOutputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
 
 /* Obsolete decompression functions */
-/* These function names are completely deprecated and must no longer be used.
-   They are only provided here for compatibility with older programs.
-    - LZ4_uncompress is the same as LZ4_decompress_fast
-    - LZ4_uncompress_unknownOutputSize is the same as LZ4_decompress_safe
-   These function prototypes are now disabled; uncomment them only if you really need them.
-   It is highly recommended to stop using these prototypes and migrate to maintained ones */
-/* int LZ4_uncompress (const char* source, char* dest, int outputSize); */
-/* int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize); */
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast() instead") int LZ4_uncompress (const char* source, char* dest, int outputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe() instead") int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
 
 /* Obsolete streaming functions; use new streaming interface whenever possible */
-LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
-LZ4_DEPRECATED("use LZ4_createStream() instead") int   LZ4_sizeofStreamState(void);
-LZ4_DEPRECATED("use LZ4_resetStream() instead")  int   LZ4_resetStreamState(void* state, char* inputBuffer);
-LZ4_DEPRECATED("use LZ4_saveDict() instead")     char* LZ4_slideInputBuffer (void* state);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") void* LZ4_create (char* inputBuffer);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStream() instead") int   LZ4_sizeofStreamState(void);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_resetStream() instead")  int   LZ4_resetStreamState(void* state, char* inputBuffer);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_saveDict() instead")     char* LZ4_slideInputBuffer (void* state);
 
 /* Obsolete streaming decoding functions */
-LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
-LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
+
+#endif /* LZ4_H_2983827168210 */
 
 
 #if defined (__cplusplus)

src/lz4/lib/lz4frame.h

@@ -1,7 +1,7 @@
 /*
    LZ4 auto-framing library
    Header File
-   Copyright (C) 2011-2015, Yann Collet.
+   Copyright (C) 2011-2017, Yann Collet.
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
    Redistribution and use in source and binary forms, with or without
@@ -28,276 +28,364 @@
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    You can contact the author at :
-   - LZ4 source repository : https://github.com/Cyan4973/lz4
+   - LZ4 source repository : https://github.com/lz4/lz4
    - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
 */
 
 /* LZ4F is a stand-alone API to create LZ4-compressed frames
- * fully conformant to specification v1.5.1.
- * All related operations, including memory management, are handled by the library.
- * You don't need lz4.h when using lz4frame.h.
+ * conformant with specification v1.5.1.
+ * It also offers streaming capabilities.
+ * lz4.h is not required when using lz4frame.h.
  * */
 
-#pragma once
+#ifndef LZ4F_H_09782039843
+#define LZ4F_H_09782039843
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
-/**************************************
-*  Includes
-**************************************/
+/* ---   Dependency   --- */
 #include <stddef.h>   /* size_t */
 
 
-/**************************************
- * Error management
- * ************************************/
+/**
+  Introduction
+
+  lz4frame.h implements LZ4 frame specification (doc/lz4_Frame_format.md).
+  lz4frame.h provides frame compression functions that take care
+  of encoding standard metadata alongside LZ4-compressed blocks.
+*/
+
+/*-***************************************************************
+ *  Compiler specifics
+ *****************************************************************/
+/*  LZ4_DLL_EXPORT :
+ *  Enable exporting of functions when building a Windows DLL
+ *  LZ4FLIB_API :
+ *  Control library symbols visibility.
+ */
+#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
+#  define LZ4FLIB_API __declspec(dllexport)
+#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
+#  define LZ4FLIB_API __declspec(dllimport)
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+#  define LZ4FLIB_API __attribute__ ((__visibility__ ("default")))
+#else
+#  define LZ4FLIB_API
+#endif
+
+#ifdef LZ4F_DISABLE_DEPRECATE_WARNINGS
+#  define LZ4F_DEPRECATE(x) x
+#else
+#  if defined(_MSC_VER)
+#    define LZ4F_DEPRECATE(x) x   /* __declspec(deprecated) x - only works with C++ */
+#  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
+#    define LZ4F_DEPRECATE(x) x __attribute__((deprecated))
+#  else
+#    define LZ4F_DEPRECATE(x) x   /* no deprecation warning for this compiler */
+#  endif
+#endif
+
+
+/*-************************************
+ *  Error management
+ **************************************/
 typedef size_t LZ4F_errorCode_t;
 
-unsigned    LZ4F_isError(LZ4F_errorCode_t code);
-const char* LZ4F_getErrorName(LZ4F_errorCode_t code);   /* return error code string; useful for debugging */
+LZ4FLIB_API unsigned    LZ4F_isError(LZ4F_errorCode_t code);   /**< tells if a `LZ4F_errorCode_t` function result is an error code */
+LZ4FLIB_API const char* LZ4F_getErrorName(LZ4F_errorCode_t code);   /**< return error code string; useful for debugging */
 
 
-/**************************************
- * Frame compression types
- * ************************************/
-//#define LZ4F_DISABLE_OBSOLETE_ENUMS
-#ifndef LZ4F_DISABLE_OBSOLETE_ENUMS
-#  define LZ4F_OBSOLETE_ENUM(x) ,x
+/*-************************************
+ *  Frame compression types
+ **************************************/
+/* #define LZ4F_ENABLE_OBSOLETE_ENUMS   // uncomment to enable obsolete enums */
+#ifdef LZ4F_ENABLE_OBSOLETE_ENUMS
+#  define LZ4F_OBSOLETE_ENUM(x) , LZ4F_DEPRECATE(x) = LZ4F_##x
 #else
 #  define LZ4F_OBSOLETE_ENUM(x)
 #endif
 
+/* The larger the block size, the (slightly) better the compression ratio,
+ * though there are diminishing returns.
+ * Larger blocks also increase memory usage on both compression and decompression sides. */
 typedef enum {
     LZ4F_default=0,
     LZ4F_max64KB=4,
     LZ4F_max256KB=5,
     LZ4F_max1MB=6,
     LZ4F_max4MB=7
-    LZ4F_OBSOLETE_ENUM(max64KB = LZ4F_max64KB)
-    LZ4F_OBSOLETE_ENUM(max256KB = LZ4F_max256KB)
-    LZ4F_OBSOLETE_ENUM(max1MB = LZ4F_max1MB)
-    LZ4F_OBSOLETE_ENUM(max4MB = LZ4F_max4MB)
+    LZ4F_OBSOLETE_ENUM(max64KB)
+    LZ4F_OBSOLETE_ENUM(max256KB)
+    LZ4F_OBSOLETE_ENUM(max1MB)
+    LZ4F_OBSOLETE_ENUM(max4MB)
 } LZ4F_blockSizeID_t;
 
+/* Linked blocks sharply reduce inefficiencies when using small blocks,
+ * they compress better.
+ * However, some LZ4 decoders are only compatible with independent blocks */
 typedef enum {
     LZ4F_blockLinked=0,
     LZ4F_blockIndependent
-    LZ4F_OBSOLETE_ENUM(blockLinked = LZ4F_blockLinked)
-    LZ4F_OBSOLETE_ENUM(blockIndependent = LZ4F_blockIndependent)
+    LZ4F_OBSOLETE_ENUM(blockLinked)
+    LZ4F_OBSOLETE_ENUM(blockIndependent)
 } LZ4F_blockMode_t;
 
 typedef enum {
     LZ4F_noContentChecksum=0,
     LZ4F_contentChecksumEnabled
-    LZ4F_OBSOLETE_ENUM(noContentChecksum = LZ4F_noContentChecksum)
-    LZ4F_OBSOLETE_ENUM(contentChecksumEnabled = LZ4F_contentChecksumEnabled)
+    LZ4F_OBSOLETE_ENUM(noContentChecksum)
+    LZ4F_OBSOLETE_ENUM(contentChecksumEnabled)
 } LZ4F_contentChecksum_t;
 
+typedef enum {
+    LZ4F_noBlockChecksum=0,
+    LZ4F_blockChecksumEnabled
+} LZ4F_blockChecksum_t;
+
 typedef enum {
     LZ4F_frame=0,
     LZ4F_skippableFrame
-    LZ4F_OBSOLETE_ENUM(skippableFrame = LZ4F_skippableFrame)
+    LZ4F_OBSOLETE_ENUM(skippableFrame)
 } LZ4F_frameType_t;
 
-#ifndef LZ4F_DISABLE_OBSOLETE_ENUMS
+#ifdef LZ4F_ENABLE_OBSOLETE_ENUMS
 typedef LZ4F_blockSizeID_t blockSizeID_t;
 typedef LZ4F_blockMode_t blockMode_t;
 typedef LZ4F_frameType_t frameType_t;
 typedef LZ4F_contentChecksum_t contentChecksum_t;
 #endif
 
+/*! LZ4F_frameInfo_t :
+ *  makes it possible to set or read frame parameters.
+ *  It's not required to set all fields, as long as the structure was initially memset() to zero.
+ *  For all fields, 0 sets it to default value */
 typedef struct {
-  LZ4F_blockSizeID_t     blockSizeID;           /* max64KB, max256KB, max1MB, max4MB ; 0 == default */
-  LZ4F_blockMode_t       blockMode;             /* blockLinked, blockIndependent ; 0 == default */
-  LZ4F_contentChecksum_t contentChecksumFlag;   /* noContentChecksum, contentChecksumEnabled ; 0 == default  */
-  LZ4F_frameType_t       frameType;             /* LZ4F_frame, skippableFrame ; 0 == default */
-  unsigned long long     contentSize;           /* Size of uncompressed (original) content ; 0 == unknown */
-  unsigned               reserved[2];           /* must be zero for forward compatibility */
+  LZ4F_blockSizeID_t     blockSizeID;          /* max64KB, max256KB, max1MB, max4MB ; 0 == default */
+  LZ4F_blockMode_t       blockMode;            /* LZ4F_blockLinked, LZ4F_blockIndependent ; 0 == default */
+  LZ4F_contentChecksum_t contentChecksumFlag;  /* if enabled, frame is terminated with a 32-bits checksum of decompressed data ; 0 == disabled (default)  */
+  LZ4F_frameType_t       frameType;            /* read-only field : LZ4F_frame or LZ4F_skippableFrame */
+  unsigned long long     contentSize;          /* Size of uncompressed content ; 0 == unknown */
+  unsigned               dictID;               /* Dictionary ID, sent by the compressor to help decoder select the correct dictionary; 0 == no dictID provided */
+  LZ4F_blockChecksum_t   blockChecksumFlag;    /* if enabled, each block is followed by a checksum of block's compressed data ; 0 == disabled (default)  */
 } LZ4F_frameInfo_t;
 
+/*! LZ4F_preferences_t :
+ *  makes it possible to supply detailed compression parameters to the stream interface.
+ *  It's not required to set all fields, as long as the structure was initially memset() to zero.
+ *  All reserved fields must be set to zero. */
 typedef struct {
   LZ4F_frameInfo_t frameInfo;
-  int      compressionLevel;       /* 0 == default (fast mode); values above 16 count as 16; values below 0 count as 0 */
-  unsigned autoFlush;              /* 1 == always flush (reduce need for tmp buffer) */
+  int      compressionLevel;       /* 0 == default (fast mode); values above LZ4HC_CLEVEL_MAX count as LZ4HC_CLEVEL_MAX; values below 0 trigger "fast acceleration", proportional to value */
+  unsigned autoFlush;              /* 1 == always flush, to reduce usage of internal buffers */
   unsigned reserved[4];            /* must be zero for forward compatibility */
 } LZ4F_preferences_t;
 
+LZ4FLIB_API int LZ4F_compressionLevel_max(void);
 
-/***********************************
- * Simple compression function
- * *********************************/
-size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr);
 
-size_t LZ4F_compressFrame(void* dstBuffer, size_t dstMaxSize, const void* srcBuffer, size_t srcSize, const LZ4F_preferences_t* preferencesPtr);
-/* LZ4F_compressFrame()
- * Compress an entire srcBuffer into a valid LZ4 frame, as defined by specification v1.5.1
- * The most important rule is that dstBuffer MUST be large enough (dstMaxSize) to ensure compression completion even in worst case.
- * You can get the minimum value of dstMaxSize by using LZ4F_compressFrameBound()
- * If this condition is not respected, LZ4F_compressFrame() will fail (result is an errorCode)
- * The LZ4F_preferences_t structure is optional : you can provide NULL as argument. All preferences will be set to default.
- * The result of the function is the number of bytes written into dstBuffer.
- * The function outputs an error code if it fails (can be tested using LZ4F_isError())
+/*-*********************************
+*  Simple compression function
+***********************************/
+/*! LZ4F_compressFrameBound() :
+ *  Returns the maximum possible size of a frame compressed with LZ4F_compressFrame() given srcSize content and preferences.
+ *  Note : this result is only usable with LZ4F_compressFrame(), not with multi-segments compression.
  */
+LZ4FLIB_API size_t LZ4F_compressFrameBound(size_t srcSize, const LZ4F_preferences_t* preferencesPtr);
+
+/*! LZ4F_compressFrame() :
+ *  Compress an entire srcBuffer into a valid LZ4 frame.
+ *  dstCapacity MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
+ *  The LZ4F_preferences_t structure is optional : you can provide NULL as argument. All preferences will be set to default.
+ * @return : number of bytes written into dstBuffer.
+ *           or an error code if it fails (can be tested using LZ4F_isError())
+ */
+LZ4FLIB_API size_t LZ4F_compressFrame(void* dstBuffer, size_t dstCapacity,
+                                const void* srcBuffer, size_t srcSize,
+                                const LZ4F_preferences_t* preferencesPtr);
 
 
-
-/**********************************
+/*-***********************************
 *  Advanced compression functions
-**********************************/
-typedef struct LZ4F_cctx_s* LZ4F_compressionContext_t;   /* must be aligned on 8-bytes */
+*************************************/
+typedef struct LZ4F_cctx_s LZ4F_cctx;   /* incomplete type */
+typedef LZ4F_cctx* LZ4F_compressionContext_t;   /* for compatibility with previous API version */
 
 typedef struct {
-  unsigned stableSrc;    /* 1 == src content will remain available on future calls to LZ4F_compress(); avoid saving src content within tmp buffer as future dictionary */
+  unsigned stableSrc;    /* 1 == src content will remain present on future calls to LZ4F_compress(); skip copying src content within tmp buffer */
   unsigned reserved[3];
 } LZ4F_compressOptions_t;
 
-/* Resource Management */
+/*---   Resource Management   ---*/
 
 #define LZ4F_VERSION 100
-LZ4F_errorCode_t LZ4F_createCompressionContext(LZ4F_compressionContext_t* cctxPtr, unsigned version);
-LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_compressionContext_t cctx);
-/* LZ4F_createCompressionContext() :
+LZ4FLIB_API unsigned LZ4F_getVersion(void);
+/*! LZ4F_createCompressionContext() :
  * The first thing to do is to create a compressionContext object, which will be used in all compression operations.
- * This is achieved using LZ4F_createCompressionContext(), which takes as argument a version and an LZ4F_preferences_t structure.
- * The version provided MUST be LZ4F_VERSION. It is intended to track potential version differences between different binaries.
- * The function will provide a pointer to a fully allocated LZ4F_compressionContext_t object.
- * If the result LZ4F_errorCode_t is not zero, there was an error during context creation.
+ * This is achieved using LZ4F_createCompressionContext(), which takes as argument a version.
+ * The version provided MUST be LZ4F_VERSION. It is intended to track potential version mismatch, notably when using DLL.
+ * The function will provide a pointer to a fully allocated LZ4F_cctx object.
+ * If @return != zero, there was an error during context creation.
  * Object can release its memory using LZ4F_freeCompressionContext();
  */
+LZ4FLIB_API LZ4F_errorCode_t LZ4F_createCompressionContext(LZ4F_cctx** cctxPtr, unsigned version);
+LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeCompressionContext(LZ4F_cctx* cctx);
 
 
-/* Compression */
+/*----    Compression    ----*/
 
-size_t LZ4F_compressBegin(LZ4F_compressionContext_t cctx, void* dstBuffer, size_t dstMaxSize, const LZ4F_preferences_t* prefsPtr);
-/* LZ4F_compressBegin() :
- * will write the frame header into dstBuffer.
- * dstBuffer must be large enough to accommodate a header (dstMaxSize). Maximum header size is 15 bytes.
- * The LZ4F_preferences_t structure is optional : you can provide NULL as argument, all preferences will then be set to default.
- * The result of the function is the number of bytes written into dstBuffer for the header
- * or an error code (can be tested using LZ4F_isError())
+#define LZ4F_HEADER_SIZE_MAX 19
+/*! LZ4F_compressBegin() :
+ *  will write the frame header into dstBuffer.
+ *  dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes.
+ * `prefsPtr` is optional : you can provide NULL as argument, all preferences will then be set to default.
+ * @return : number of bytes written into dstBuffer for the header
+ *           or an error code (which can be tested using LZ4F_isError())
  */
+LZ4FLIB_API size_t LZ4F_compressBegin(LZ4F_cctx* cctx,
+                                      void* dstBuffer, size_t dstCapacity,
+                                      const LZ4F_preferences_t* prefsPtr);
 
-size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* prefsPtr);
-/* LZ4F_compressBound() :
- * Provides the minimum size of Dst buffer given srcSize to handle worst case situations.
- * Different preferences can produce different results.
- * prefsPtr is optional : you can provide NULL as argument, all preferences will then be set to cover worst case.
- * This function includes frame termination cost (4 bytes, or 8 if frame checksum is enabled)
+/*! LZ4F_compressBound() :
+ * Provides dstCapacity given a srcSize to guarantee operation success in worst case situations.
+ * prefsPtr is optional : you can provide NULL as argument, preferences will be set to cover worst case scenario.
+ * Result is always the same for a srcSize and prefsPtr, so it can be trusted to size reusable buffers.
+ * When srcSize==0, LZ4F_compressBound() provides an upper bound for LZ4F_flush() and LZ4F_compressEnd() operations.
  */
+LZ4FLIB_API size_t LZ4F_compressBound(size_t srcSize, const LZ4F_preferences_t* prefsPtr);
 
-size_t LZ4F_compressUpdate(LZ4F_compressionContext_t cctx, void* dstBuffer, size_t dstMaxSize, const void* srcBuffer, size_t srcSize, const LZ4F_compressOptions_t* cOptPtr);
-/* LZ4F_compressUpdate()
+/*! LZ4F_compressUpdate() :
  * LZ4F_compressUpdate() can be called repetitively to compress as much data as necessary.
- * The most important rule is that dstBuffer MUST be large enough (dstMaxSize) to ensure compression completion even in worst case.
- * You can get the minimum value of dstMaxSize by using LZ4F_compressBound().
+ * An important rule is that dstCapacity MUST be large enough to ensure operation success even in worst case situations.
+ * This value is provided by LZ4F_compressBound().
  * If this condition is not respected, LZ4F_compress() will fail (result is an errorCode).
- * LZ4F_compressUpdate() doesn't guarantee error recovery, so you have to reset compression context when an error occurs.
- * The LZ4F_compressOptions_t structure is optional : you can provide NULL as argument.
- * The result of the function is the number of bytes written into dstBuffer : it can be zero, meaning input data was just buffered.
- * The function outputs an error code if it fails (can be tested using LZ4F_isError())
+ * LZ4F_compressUpdate() doesn't guarantee error recovery. When an error occurs, compression context must be freed or resized.
+ * `cOptPtr` is optional : NULL can be provided, in which case all options are set to default.
+ * @return : number of bytes written into `dstBuffer` (it can be zero, meaning input data was just buffered).
+ *           or an error code if it fails (which can be tested using LZ4F_isError())
  */
+LZ4FLIB_API size_t LZ4F_compressUpdate(LZ4F_cctx* cctx, void* dstBuffer, size_t dstCapacity, const void* srcBuffer, size_t srcSize, const LZ4F_compressOptions_t* cOptPtr);
 
-size_t LZ4F_flush(LZ4F_compressionContext_t cctx, void* dstBuffer, size_t dstMaxSize, const LZ4F_compressOptions_t* cOptPtr);
-/* LZ4F_flush()
- * Should you need to generate compressed data immediately, without waiting for the current block to be filled,
- * you can call LZ4_flush(), which will immediately compress any remaining data buffered within cctx.
- * Note that dstMaxSize must be large enough to ensure the operation will be successful.
- * LZ4F_compressOptions_t structure is optional : you can provide NULL as argument.
- * The result of the function is the number of bytes written into dstBuffer
- * (it can be zero, this means there was no data left within cctx)
- * The function outputs an error code if it fails (can be tested using LZ4F_isError())
+/*! LZ4F_flush() :
+ * When data must be generated and sent immediately, without waiting for a block to be completely filled,
+ * it's possible to call LZ4_flush(). It will immediately compress any data buffered within cctx.
+ * `dstCapacity` must be large enough to ensure the operation will be successful.
+ * `cOptPtr` is optional : it's possible to provide NULL, all options will be set to default.
+ * @return : number of bytes written into dstBuffer (it can be zero, which means there was no data stored within cctx)
+ *           or an error code if it fails (which can be tested using LZ4F_isError())
  */
+LZ4FLIB_API size_t LZ4F_flush(LZ4F_cctx* cctx, void* dstBuffer, size_t dstCapacity, const LZ4F_compressOptions_t* cOptPtr);
 
-size_t LZ4F_compressEnd(LZ4F_compressionContext_t cctx, void* dstBuffer, size_t dstMaxSize, const LZ4F_compressOptions_t* cOptPtr);
-/* LZ4F_compressEnd()
- * When you want to properly finish the compressed frame, just call LZ4F_compressEnd().
- * It will flush whatever data remained within compressionContext (like LZ4_flush())
- * but also properly finalize the frame, with an endMark and a checksum.
- * The result of the function is the number of bytes written into dstBuffer (necessarily >= 4 (endMark), or 8 if optional frame checksum is enabled)
- * The function outputs an error code if it fails (can be tested using LZ4F_isError())
- * The LZ4F_compressOptions_t structure is optional : you can provide NULL as argument.
- * A successful call to LZ4F_compressEnd() makes cctx available again for next compression task.
+/*! LZ4F_compressEnd() :
+ *  To properly finish an LZ4 frame, invoke LZ4F_compressEnd().
+ *  It will flush whatever data remained within `cctx` (like LZ4_flush())
+ *  and properly finalize the frame, with an endMark and a checksum.
+ * `cOptPtr` is optional : NULL can be provided, in which case all options will be set to default.
+ * @return : number of bytes written into dstBuffer (necessarily >= 4 (endMark), or 8 if optional frame checksum is enabled)
+ *           or an error code if it fails (which can be tested using LZ4F_isError())
+ *  A successful call to LZ4F_compressEnd() makes `cctx` available again for another compression task.
  */
+LZ4FLIB_API size_t LZ4F_compressEnd(LZ4F_cctx* cctx, void* dstBuffer, size_t dstCapacity, const LZ4F_compressOptions_t* cOptPtr);
 
 
-/***********************************
+/*-*********************************
 *  Decompression functions
 ***********************************/
-
-typedef struct LZ4F_dctx_s* LZ4F_decompressionContext_t;   /* must be aligned on 8-bytes */
+typedef struct LZ4F_dctx_s LZ4F_dctx;   /* incomplete type */
+typedef LZ4F_dctx* LZ4F_decompressionContext_t;   /* compatibility with previous API versions */
 
 typedef struct {
-  unsigned stableDst;       /* guarantee that decompressed data will still be there on next function calls (avoid storage into tmp buffers) */
-  unsigned reserved[3];
+  unsigned stableDst;    /* pledge that at least 64KB+64Bytes of previously decompressed data remain unmodifed where it was decoded. This optimization skips storage operations in tmp buffers */
+  unsigned reserved[3];  /* must be set to zero for forward compatibility */
 } LZ4F_decompressOptions_t;
 
 
 /* Resource management */
 
-LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_decompressionContext_t* dctxPtr, unsigned version);
-LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_decompressionContext_t dctx);
-/* LZ4F_createDecompressionContext() :
- * The first thing to do is to create an LZ4F_decompressionContext_t object, which will be used in all decompression operations.
- * This is achieved using LZ4F_createDecompressionContext().
- * The version provided MUST be LZ4F_VERSION. It is intended to track potential breaking differences between different versions.
- * The function will provide a pointer to a fully allocated and initialized LZ4F_decompressionContext_t object.
+/*!LZ4F_createDecompressionContext() :
+ * Create an LZ4F_dctx object, to track all decompression operations.
+ * The version provided MUST be LZ4F_VERSION.
+ * The function provides a pointer to an allocated and initialized LZ4F_dctx object.
  * The result is an errorCode, which can be tested using LZ4F_isError().
  * dctx memory can be released using LZ4F_freeDecompressionContext();
  * The result of LZ4F_freeDecompressionContext() is indicative of the current state of decompressionContext when being released.
  * That is, it should be == 0 if decompression has been completed fully and correctly.
  */
+LZ4FLIB_API LZ4F_errorCode_t LZ4F_createDecompressionContext(LZ4F_dctx** dctxPtr, unsigned version);
+LZ4FLIB_API LZ4F_errorCode_t LZ4F_freeDecompressionContext(LZ4F_dctx* dctx);
 
 
-/* Decompression */
+/*-***********************************
+*  Streaming decompression functions
+*************************************/
 
-size_t LZ4F_getFrameInfo(LZ4F_decompressionContext_t dctx,
-                         LZ4F_frameInfo_t* frameInfoPtr,
-                         const void* srcBuffer, size_t* srcSizePtr);
-/* LZ4F_getFrameInfo()
- * This function decodes frame header information (such as max blockSize, frame checksum, etc.).
- * Its usage is optional : you can start by calling directly LZ4F_decompress() instead.
- * The objective is to extract frame header information, typically for allocation purposes.
- * LZ4F_getFrameInfo() can also be used anytime *after* starting decompression, on any valid LZ4F_decompressionContext_t.
- * The result is *copied* into an existing LZ4F_frameInfo_t structure which must be already allocated.
- * The number of bytes read from srcBuffer will be provided within *srcSizePtr (necessarily <= original value).
- * The function result is an hint of how many srcSize bytes LZ4F_decompress() expects for next call,
- *                        or an error code which can be tested using LZ4F_isError()
- *                        (typically, when there is not enough src bytes to fully decode the frame header)
- * You are expected to resume decompression from where it stopped (srcBuffer + *srcSizePtr)
+/*! LZ4F_getFrameInfo() :
+ *  This function extracts frame parameters (max blockSize, dictID, etc.).
+ *  Its usage is optional.
+ *  Extracted information is typically useful for allocation and dictionary.
+ *  This function works in 2 situations :
+ *   - At the beginning of a new frame, in which case
+ *     it will decode information from `srcBuffer`, starting the decoding process.
+ *     Input size must be large enough to successfully decode the entire frame header.
+ *     Frame header size is variable, but is guaranteed to be <= LZ4F_HEADER_SIZE_MAX bytes.
+ *     It's allowed to provide more input data than this minimum.
+ *   - After decoding has been started.
+ *     In which case, no input is read, frame parameters are extracted from dctx.
+ *   - If decoding has barely started, but not yet extracted information from header,
+ *     LZ4F_getFrameInfo() will fail.
+ *  The number of bytes consumed from srcBuffer will be updated within *srcSizePtr (necessarily <= original value).
+ *  Decompression must resume from (srcBuffer + *srcSizePtr).
+ * @return : an hint about how many srcSize bytes LZ4F_decompress() expects for next call,
+ *           or an error code which can be tested using LZ4F_isError().
+ *  note 1 : in case of error, dctx is not modified. Decoding operation can resume from beginning safely.
+ *  note 2 : frame parameters are *copied into* an already allocated LZ4F_frameInfo_t structure.
  */
+LZ4FLIB_API size_t LZ4F_getFrameInfo(LZ4F_dctx* dctx,
+                                     LZ4F_frameInfo_t* frameInfoPtr,
+                                     const void* srcBuffer, size_t* srcSizePtr);
 
-size_t LZ4F_decompress(LZ4F_decompressionContext_t dctx,
-                       void* dstBuffer, size_t* dstSizePtr,
-                       const void* srcBuffer, size_t* srcSizePtr,
-                       const LZ4F_decompressOptions_t* dOptPtr);
-/* LZ4F_decompress()
- * Call this function repetitively to regenerate data compressed within srcBuffer.
- * The function will attempt to decode *srcSizePtr bytes from srcBuffer, into dstBuffer of maximum size *dstSizePtr.
+/*! LZ4F_decompress() :
+ *  Call this function repetitively to regenerate compressed data from `srcBuffer`.
+ *  The function will attempt to decode up to *srcSizePtr bytes from srcBuffer, into dstBuffer of capacity *dstSizePtr.
  *
- * The number of bytes regenerated into dstBuffer will be provided within *dstSizePtr (necessarily <= original value).
+ *  The number of bytes regenerated into dstBuffer is provided within *dstSizePtr (necessarily <= original value).
  *
- * The number of bytes read from srcBuffer will be provided within *srcSizePtr (necessarily <= original value).
- * If number of bytes read is < number of bytes provided, then decompression operation is not completed.
- * It typically happens when dstBuffer is not large enough to contain all decoded data.
- * LZ4F_decompress() must be called again, starting from where it stopped (srcBuffer + *srcSizePtr)
- * The function will check this condition, and refuse to continue if it is not respected.
+ *  The number of bytes consumed from srcBuffer is provided within *srcSizePtr (necessarily <= original value).
+ *  Number of bytes consumed can be < number of bytes provided.
+ *  It typically happens when dstBuffer is not large enough to contain all decoded data.
+ *  Unconsumed source data must be presented again in subsequent invocations.
  *
- * dstBuffer is supposed to be flushed between each call to the function, since its content will be overwritten.
- * dst arguments can be changed at will with each consecutive call to the function.
+ * `dstBuffer` content is expected to be flushed between each invocation, as its content will be overwritten.
+ * `dstBuffer` itself can be changed at will between each consecutive function invocation.
  *
- * The function result is an hint of how many srcSize bytes LZ4F_decompress() expects for next call.
- * Schematically, it's the size of the current (or remaining) compressed block + header of next block.
- * Respecting the hint provides some boost to performance, since it does skip intermediate buffers.
- * This is just a hint, you can always provide any srcSize you want.
- * When a frame is fully decoded, the function result will be 0 (no more data expected).
- * If decompression failed, function result is an error code, which can be tested using LZ4F_isError().
+ * @return : an hint of how many `srcSize` bytes LZ4F_decompress() expects for next call.
+ *  Schematically, it's the size of the current (or remaining) compressed block + header of next block.
+ *  Respecting the hint provides some small speed benefit, because it skips intermediate buffers.
+ *  This is just a hint though, it's always possible to provide any srcSize.
+ *  When a frame is fully decoded, @return will be 0 (no more data expected).
+ *  If decompression failed, @return is an error code, which can be tested using LZ4F_isError().
  *
- * After a frame is fully decoded, dctx can be used again to decompress another frame.
+ *  After a frame is fully decoded, dctx can be used again to decompress another frame.
+ *  After a decompression error, use LZ4F_resetDecompressionContext() before re-using dctx, to return to clean state.
  */
+LZ4FLIB_API size_t LZ4F_decompress(LZ4F_dctx* dctx,
+                                   void* dstBuffer, size_t* dstSizePtr,
+                                   const void* srcBuffer, size_t* srcSizePtr,
+                                   const LZ4F_decompressOptions_t* dOptPtr);
+
+
+/*! LZ4F_resetDecompressionContext() : v1.8.0
+ *  In case of an error, the context is left in "undefined" state.
+ *  In which case, it's necessary to reset it, before re-using it.
+ *  This method can also be used to abruptly stop an unfinished decompression,
+ *  and start a new one using the same context. */
+LZ4FLIB_API void LZ4F_resetDecompressionContext(LZ4F_dctx* dctx);   /* always successful */
+
 
 
 #if defined (__cplusplus)
 }
 #endif
+
+#endif  /* LZ4F_H_09782039843 */

src/lz4/lib/lz4frame_static.h

@@ -1,7 +1,7 @@
 /*
    LZ4 auto-framing library
    Header File for static linking only
-   Copyright (C) 2011-2015, Yann Collet.
+   Copyright (C) 2011-2016, Yann Collet.
 
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
@@ -29,53 +29,115 @@
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    You can contact the author at :
-   - LZ4 source repository : https://github.com/Cyan4973/lz4
+   - LZ4 source repository : https://github.com/lz4/lz4
    - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
 */
 
-#pragma once
+#ifndef LZ4FRAME_STATIC_H_0398209384
+#define LZ4FRAME_STATIC_H_0398209384
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
 /* lz4frame_static.h should be used solely in the context of static linking.
- * It contains definitions which may still change overtime.
+ * It contains definitions which are not stable and may change in the future.
  * Never use it in the context of DLL linking.
- * */
+ */
 
 
-/**************************************
-*  Includes
-**************************************/
+/* ---   Dependency   --- */
 #include "lz4frame.h"
 
 
-/**************************************
- * Error management
- * ************************************/
+/* ---   Error List   --- */
 #define LZ4F_LIST_ERRORS(ITEM) \
-        ITEM(OK_NoError) ITEM(ERROR_GENERIC) \
-        ITEM(ERROR_maxBlockSize_invalid) ITEM(ERROR_blockMode_invalid) ITEM(ERROR_contentChecksumFlag_invalid) \
+        ITEM(OK_NoError) \
+        ITEM(ERROR_GENERIC) \
+        ITEM(ERROR_maxBlockSize_invalid) \
+        ITEM(ERROR_blockMode_invalid) \
+        ITEM(ERROR_contentChecksumFlag_invalid) \
         ITEM(ERROR_compressionLevel_invalid) \
-        ITEM(ERROR_headerVersion_wrong) ITEM(ERROR_blockChecksum_unsupported) ITEM(ERROR_reservedFlag_set) \
+        ITEM(ERROR_headerVersion_wrong) \
+        ITEM(ERROR_blockChecksum_invalid) \
+        ITEM(ERROR_reservedFlag_set) \
         ITEM(ERROR_allocation_failed) \
-        ITEM(ERROR_srcSize_tooLarge) ITEM(ERROR_dstMaxSize_tooSmall) \
-        ITEM(ERROR_frameHeader_incomplete) ITEM(ERROR_frameType_unknown) ITEM(ERROR_frameSize_wrong) \
+        ITEM(ERROR_srcSize_tooLarge) \
+        ITEM(ERROR_dstMaxSize_tooSmall) \
+        ITEM(ERROR_frameHeader_incomplete) \
+        ITEM(ERROR_frameType_unknown) \
+        ITEM(ERROR_frameSize_wrong) \
         ITEM(ERROR_srcPtr_wrong) \
         ITEM(ERROR_decompressionFailed) \
-        ITEM(ERROR_headerChecksum_invalid) ITEM(ERROR_contentChecksum_invalid) \
+        ITEM(ERROR_headerChecksum_invalid) \
+        ITEM(ERROR_contentChecksum_invalid) \
+        ITEM(ERROR_frameDecoding_alreadyStarted) \
         ITEM(ERROR_maxCode)
 
-//#define LZ4F_DISABLE_OLD_ENUMS
-#ifndef LZ4F_DISABLE_OLD_ENUMS
-#define LZ4F_GENERATE_ENUM(ENUM) LZ4F_##ENUM, ENUM = LZ4F_##ENUM,
-#else
 #define LZ4F_GENERATE_ENUM(ENUM) LZ4F_##ENUM,
-#endif
-typedef enum { LZ4F_LIST_ERRORS(LZ4F_GENERATE_ENUM) } LZ4F_errorCodes;  /* enum is exposed, to handle specific errors; compare function result to -enum value */
+
+/* enum list is exposed, to handle specific errors */
+typedef enum { LZ4F_LIST_ERRORS(LZ4F_GENERATE_ENUM) } LZ4F_errorCodes;
+
+LZ4F_errorCodes LZ4F_getErrorCode(size_t functionResult);
+
+
+
+/**********************************
+ *  Bulk processing dictionary API
+ *********************************/
+typedef struct LZ4F_CDict_s LZ4F_CDict;
+
+/*! LZ4_createCDict() :
+ *  When compressing multiple messages / blocks with the same dictionary, it's recommended to load it just once.
+ *  LZ4_createCDict() will create a digested dictionary, ready to start future compression operations without startup delay.
+ *  LZ4_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.
+ * `dictBuffer` can be released after LZ4_CDict creation, since its content is copied within CDict */
+LZ4F_CDict* LZ4F_createCDict(const void* dictBuffer, size_t dictSize);
+void        LZ4F_freeCDict(LZ4F_CDict* CDict);
+
+
+/*! LZ4_compressFrame_usingCDict() :
+ *  Compress an entire srcBuffer into a valid LZ4 frame using a digested Dictionary.
+ *  If cdict==NULL, compress without a dictionary.
+ *  dstBuffer MUST be >= LZ4F_compressFrameBound(srcSize, preferencesPtr).
+ *  If this condition is not respected, function will fail (@return an errorCode).
+ *  The LZ4F_preferences_t structure is optional : you may provide NULL as argument,
+ *  but it's not recommended, as it's the only way to provide dictID in the frame header.
+ * @return : number of bytes written into dstBuffer.
+ *           or an error code if it fails (can be tested using LZ4F_isError()) */
+size_t LZ4F_compressFrame_usingCDict(void* dst, size_t dstCapacity,
+                               const void* src, size_t srcSize,
+                               const LZ4F_CDict* cdict,
+                               const LZ4F_preferences_t* preferencesPtr);
+
+
+/*! LZ4F_compressBegin_usingCDict() :
+ *  Inits streaming dictionary compression, and writes the frame header into dstBuffer.
+ *  dstCapacity must be >= LZ4F_HEADER_SIZE_MAX bytes.
+ * `prefsPtr` is optional : you may provide NULL as argument,
+ *  however, it's the only way to provide dictID in the frame header.
+ * @return : number of bytes written into dstBuffer for the header,
+ *           or an error code (which can be tested using LZ4F_isError()) */
+size_t LZ4F_compressBegin_usingCDict(LZ4F_cctx* cctx,
+                                     void* dstBuffer, size_t dstCapacity,
+                                     const LZ4F_CDict* cdict,
+                                     const LZ4F_preferences_t* prefsPtr);
+
+
+/*! LZ4F_decompress_usingDict() :
+ *  Same as LZ4F_decompress(), using a predefined dictionary.
+ *  Dictionary is used "in place", without any preprocessing.
+ *  It must remain accessible throughout the entire frame decoding. */
+size_t LZ4F_decompress_usingDict(LZ4F_dctx* dctxPtr,
+                       void* dstBuffer, size_t* dstSizePtr,
+                       const void* srcBuffer, size_t* srcSizePtr,
+                       const void* dict, size_t dictSize,
+                       const LZ4F_decompressOptions_t* decompressOptionsPtr);
 
 
 #if defined (__cplusplus)
 }
 #endif
+
+#endif /* LZ4FRAME_STATIC_H_0398209384 */

src/lz4/lib/lz4hc.c

@@ -1,6 +1,6 @@
 /*
     LZ4 HC - High Compression Mode of LZ4
-    Copyright (C) 2011-2015, Yann Collet.
+    Copyright (C) 2011-2017, Yann Collet.
 
     BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
@@ -28,83 +28,52 @@
     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
     You can contact the author at :
-       - LZ4 source repository : https://github.com/Cyan4973/lz4
+       - LZ4 source repository : https://github.com/lz4/lz4
        - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
 */
+/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */
 
 
-
-/**************************************
+/* *************************************
 *  Tuning Parameter
-**************************************/
-static const int LZ4HC_compressionLevel_default = 9;
+***************************************/
+
+/*! HEAPMODE :
+ *  Select how default compression function will allocate workplace memory,
+ *  in stack (0:fastest), or in heap (1:requires malloc()).
+ *  Since workplace is rather large, heap mode is recommended.
+ */
+#ifndef LZ4HC_HEAPMODE
+#  define LZ4HC_HEAPMODE 1
+#endif
 
 
-/**************************************
-*  Includes
-**************************************/
+/*===    Dependency    ===*/
 #include "lz4hc.h"
 
 
-/**************************************
-*  Local Compiler Options
-**************************************/
+/*===   Common LZ4 definitions   ===*/
 #if defined(__GNUC__)
 #  pragma GCC diagnostic ignored "-Wunused-function"
 #endif
-
 #if defined (__clang__)
 #  pragma clang diagnostic ignored "-Wunused-function"
 #endif
 
-
-/**************************************
-*  Common LZ4 definition
-**************************************/
 #define LZ4_COMMONDEFS_ONLY
-#include "lz4.c"
+#include "lz4.c"   /* LZ4_count, constants, mem */
 
 
-/**************************************
-*  Local Constants
-**************************************/
-#define DICTIONARY_LOGSIZE 16
-#define MAXD (1<<DICTIONARY_LOGSIZE)
-#define MAXD_MASK (MAXD - 1)
-
-#define HASH_LOG (DICTIONARY_LOGSIZE-1)
-#define HASHTABLESIZE (1 << HASH_LOG)
-#define HASH_MASK (HASHTABLESIZE - 1)
-
+/*===   Constants   ===*/
 #define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)
 
-static const int g_maxCompressionLevel = 16;
 
-
-/**************************************
-*  Local Types
-**************************************/
-typedef struct
-{
-    U32   hashTable[HASHTABLESIZE];
-    U16   chainTable[MAXD];
-    const BYTE* end;        /* next block here to continue on current prefix */
-    const BYTE* base;       /* All index relative to this position */
-    const BYTE* dictBase;   /* alternate base for extDict */
-    BYTE* inputBuffer;      /* deprecated */
-    U32   dictLimit;        /* below that point, need extDict */
-    U32   lowLimit;         /* below that point, no more dict */
-    U32   nextToUpdate;     /* index from which to continue dictionary update */
-    U32   compressionLevel;
-} LZ4HC_Data_Structure;
-
-
-/**************************************
-*  Local Macros
-**************************************/
-#define HASH_FUNCTION(i)       (((i) * 2654435761U) >> ((MINMATCH*8)-HASH_LOG))
-//#define DELTANEXTU16(p)        chainTable[(p) & MAXD_MASK]   /* flexible, MAXD dependent */
-#define DELTANEXTU16(p)        chainTable[(U16)(p)]   /* faster */
+/*===   Macros   ===*/
+#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
+#define MAX(a,b)   ( (a) > (b) ? (a) : (b) )
+#define HASH_FUNCTION(i)         (((i) * 2654435761U) >> ((MINMATCH*8)-LZ4HC_HASH_LOG))
+#define DELTANEXTMAXD(p)         chainTable[(p) & LZ4HC_MAXD_MASK]    /* flexible, LZ4HC_MAXD dependent */
+#define DELTANEXTU16(table, pos) table[(U16)(pos)]   /* faster */
 
 static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); }
 
@@ -113,7 +82,7 @@ static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)
 /**************************************
 *  HC Compression
 **************************************/
-static void LZ4HC_init (LZ4HC_Data_Structure* hc4, const BYTE* start)
+static void LZ4HC_init (LZ4HC_CCtx_internal* hc4, const BYTE* start)
 {
     MEM_INIT((void*)hc4->hashTable, 0, sizeof(hc4->hashTable));
     MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));
@@ -127,21 +96,20 @@ static void LZ4HC_init (LZ4HC_Data_Structure* hc4, const BYTE* start)
 
 
 /* Update chains up to ip (excluded) */
-FORCE_INLINE void LZ4HC_Insert (LZ4HC_Data_Structure* hc4, const BYTE* ip)
+FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)
 {
-    U16* chainTable = hc4->chainTable;
-    U32* HashTable  = hc4->hashTable;
+    U16* const chainTable = hc4->chainTable;
+    U32* const hashTable  = hc4->hashTable;
     const BYTE* const base = hc4->base;
-    const U32 target = (U32)(ip - base);
+    U32 const target = (U32)(ip - base);
     U32 idx = hc4->nextToUpdate;
 
-    while(idx < target)
-    {
-        U32 h = LZ4HC_hashPtr(base+idx);
-        size_t delta = idx - HashTable[h];
+    while (idx < target) {
+        U32 const h = LZ4HC_hashPtr(base+idx);
+        size_t delta = idx - hashTable[h];
         if (delta>MAX_DISTANCE) delta = MAX_DISTANCE;
-        DELTANEXTU16(idx) = (U16)delta;
-        HashTable[h] = idx;
+        DELTANEXTU16(chainTable, idx) = (U16)delta;
+        hashTable[h] = idx;
         idx++;
     }
 
@@ -149,8 +117,8 @@ FORCE_INLINE void LZ4HC_Insert (LZ4HC_Data_Structure* hc4, const BYTE* ip)
 }
 
 
-FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4,   /* Index table will be updated */
-                                               const BYTE* ip, const BYTE* const iLimit,
+FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_CCtx_internal* const hc4,   /* Index table will be updated */
+                                               const BYTE* const ip, const BYTE* const iLimit,
                                                const BYTE** matchpos,
                                                const int maxNbAttempts)
 {
@@ -161,32 +129,26 @@ FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4,   /* I
     const U32 dictLimit = hc4->dictLimit;
     const U32 lowLimit = (hc4->lowLimit + 64 KB > (U32)(ip-base)) ? hc4->lowLimit : (U32)(ip - base) - (64 KB - 1);
     U32 matchIndex;
-    const BYTE* match;
-    int nbAttempts=maxNbAttempts;
-    size_t ml=0;
+    int nbAttempts = maxNbAttempts;
+    size_t ml = 0;
 
     /* HC4 match finder */
     LZ4HC_Insert(hc4, ip);
     matchIndex = HashTable[LZ4HC_hashPtr(ip)];
 
-    while ((matchIndex>=lowLimit) && (nbAttempts))
-    {
+    while ((matchIndex>=lowLimit) && (nbAttempts)) {
         nbAttempts--;
-        if (matchIndex >= dictLimit)
-        {
-            match = base + matchIndex;
-            if (*(match+ml) == *(ip+ml)
-                && (LZ4_read32(match) == LZ4_read32(ip)))
+        if (matchIndex >= dictLimit) {
+            const BYTE* const match = base + matchIndex;
+            if ( (*(match+ml) == *(ip+ml))   /* can be longer */
+               && (LZ4_read32(match) == LZ4_read32(ip)) )
             {
-                size_t mlt = LZ4_count(ip+MINMATCH, match+MINMATCH, iLimit) + MINMATCH;
+                size_t const mlt = LZ4_count(ip+MINMATCH, match+MINMATCH, iLimit) + MINMATCH;
                 if (mlt > ml) { ml = mlt; *matchpos = match; }
             }
-        }
-        else
-        {
-            match = dictBase + matchIndex;
-            if (LZ4_read32(match) == LZ4_read32(ip))
-            {
+        } else {
+            const BYTE* const match = dictBase + matchIndex;
+            if (LZ4_read32(match) == LZ4_read32(ip)) {
                 size_t mlt;
                 const BYTE* vLimit = ip + (dictLimit - matchIndex);
                 if (vLimit > iLimit) vLimit = iLimit;
@@ -196,7 +158,7 @@ FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4,   /* I
                 if (mlt > ml) { ml = mlt; *matchpos = base + matchIndex; }   /* virtual matchpos */
             }
         }
-        matchIndex -= DELTANEXTU16(matchIndex);
+        matchIndex -= DELTANEXTU16(chainTable, matchIndex);
     }
 
     return (int)ml;
@@ -204,7 +166,7 @@ FORCE_INLINE int LZ4HC_InsertAndFindBestMatch (LZ4HC_Data_Structure* hc4,   /* I
 
 
 FORCE_INLINE int LZ4HC_InsertAndGetWiderMatch (
-    LZ4HC_Data_Structure* hc4,
+    LZ4HC_CCtx_internal* hc4,
     const BYTE* const ip,
     const BYTE* const iLowLimit,
     const BYTE* const iHighLimit,
@@ -220,48 +182,41 @@ FORCE_INLINE int LZ4HC_InsertAndGetWiderMatch (
     const BYTE* const lowPrefixPtr = base + dictLimit;
     const U32 lowLimit = (hc4->lowLimit + 64 KB > (U32)(ip-base)) ? hc4->lowLimit : (U32)(ip - base) - (64 KB - 1);
     const BYTE* const dictBase = hc4->dictBase;
-    U32   matchIndex;
+    int const delta = (int)(ip-iLowLimit);
     int nbAttempts = maxNbAttempts;
-    int delta = (int)(ip-iLowLimit);
+    U32 matchIndex;
 
 
     /* First Match */
     LZ4HC_Insert(hc4, ip);
     matchIndex = HashTable[LZ4HC_hashPtr(ip)];
 
-    while ((matchIndex>=lowLimit) && (nbAttempts))
-    {
+    while ((matchIndex>=lowLimit) && (nbAttempts)) {
         nbAttempts--;
-        if (matchIndex >= dictLimit)
-        {
-            const BYTE* matchPtr = base + matchIndex;
-            if (*(iLowLimit + longest) == *(matchPtr - delta + longest))
-                if (LZ4_read32(matchPtr) == LZ4_read32(ip))
-                {
+        if (matchIndex >= dictLimit) {
+            const BYTE* const matchPtr = base + matchIndex;
+            if (*(iLowLimit + longest) == *(matchPtr - delta + longest)) {
+                if (LZ4_read32(matchPtr) == LZ4_read32(ip)) {
                     int mlt = MINMATCH + LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, iHighLimit);
                     int back = 0;
 
-                    while ((ip+back>iLowLimit)
-                           && (matchPtr+back > lowPrefixPtr)
-                           && (ip[back-1] == matchPtr[back-1]))
+                    while ( (ip+back > iLowLimit)
+                         && (matchPtr+back > lowPrefixPtr)
+                         && (ip[back-1] == matchPtr[back-1])) {
                             back--;
+                    }
 
                     mlt -= back;
 
-                    if (mlt > longest)
-                    {
-                        longest = (int)mlt;
+                    if (mlt > longest) {
+                        longest = mlt;
                         *matchpos = matchPtr+back;
                         *startpos = ip+back;
-                    }
-                }
-        }
-        else
-        {
-            const BYTE* matchPtr = dictBase + matchIndex;
-            if (LZ4_read32(matchPtr) == LZ4_read32(ip))
-            {
-                size_t mlt;
+            }   }   }
+        } else {
+            const BYTE* const matchPtr = dictBase + matchIndex;
+            if (LZ4_read32(matchPtr) == LZ4_read32(ip)) {
+                int mlt;
                 int back=0;
                 const BYTE* vLimit = ip + (dictLimit - matchIndex);
                 if (vLimit > iHighLimit) vLimit = iHighLimit;
@@ -270,45 +225,57 @@ FORCE_INLINE int LZ4HC_InsertAndGetWiderMatch (
                     mlt += LZ4_count(ip+mlt, base+dictLimit, iHighLimit);
                 while ((ip+back > iLowLimit) && (matchIndex+back > lowLimit) && (ip[back-1] == matchPtr[back-1])) back--;
                 mlt -= back;
-                if ((int)mlt > longest) { longest = (int)mlt; *matchpos = base + matchIndex + back; *startpos = ip+back; }
+                if (mlt > longest) { longest = mlt; *matchpos = base + matchIndex + back; *startpos = ip+back; }
             }
         }
-        matchIndex -= DELTANEXTU16(matchIndex);
+        matchIndex -= DELTANEXTU16(chainTable, matchIndex);
     }
 
     return longest;
 }
 
 
-typedef enum { noLimit = 0, limitedOutput = 1 } limitedOutput_directive;
+typedef enum {
+    noLimit = 0,
+    limitedOutput = 1,
+    limitedDestSize = 2,
+} limitedOutput_directive;
 
-#define LZ4HC_DEBUG 0
-#if LZ4HC_DEBUG
-static unsigned debug = 0;
+#ifndef LZ4HC_DEBUG
+#  define LZ4HC_DEBUG 0
 #endif
 
+/* LZ4HC_encodeSequence() :
+ * @return : 0 if ok,
+ *           1 if buffer issue detected */
 FORCE_INLINE int LZ4HC_encodeSequence (
     const BYTE** ip,
     BYTE** op,
     const BYTE** anchor,
     int matchLength,
     const BYTE* const match,
-    limitedOutput_directive limitedOutputBuffer,
+    limitedOutput_directive limit,
     BYTE* oend)
 {
-    int length;
-    BYTE* token;
+    size_t length;
+    BYTE* const token = (*op)++;
 
 #if LZ4HC_DEBUG
-    if (debug) printf("literal : %u  --  match : %u  --  offset : %u\n", (U32)(*ip - *anchor), (U32)matchLength, (U32)(*ip-match));
+    printf("literal : %u  --  match : %u  --  offset : %u\n",
+           (U32)(*ip - *anchor), (U32)matchLength, (U32)(*ip-match));
 #endif
 
     /* Encode Literal length */
-    length = (int)(*ip - *anchor);
-    token = (*op)++;
-    if ((limitedOutputBuffer) && ((*op + (length>>8) + length + (2 + 1 + LASTLITERALS)) > oend)) return 1;   /* Check output limit */
-    if (length>=(int)RUN_MASK) { int len; *token=(RUN_MASK<<ML_BITS); len = length-RUN_MASK; for(; len > 254 ; len-=255) *(*op)++ = 255;  *(*op)++ = (BYTE)len; }
-    else *token = (BYTE)(length<<ML_BITS);
+    length = (size_t)(*ip - *anchor);
+    if ((limit) && ((*op + (length >> 8) + length + (2 + 1 + LASTLITERALS)) > oend)) return 1;   /* Check output limit */
+    if (length >= RUN_MASK) {
+        size_t len = length - RUN_MASK;
+        *token = (RUN_MASK << ML_BITS);
+        for(; len >= 255 ; len -= 255) *(*op)++ = 255;
+        *(*op)++ = (BYTE)len;
+    } else {
+        *token = (BYTE)(length << ML_BITS);
+    }
 
     /* Copy Literals */
     LZ4_wildCopy(*op, *anchor, (*op) + length);
@@ -318,10 +285,17 @@ FORCE_INLINE int LZ4HC_encodeSequence (
     LZ4_writeLE16(*op, (U16)(*ip-match)); *op += 2;
 
     /* Encode MatchLength */
-    length = (int)(matchLength-MINMATCH);
-    if ((limitedOutputBuffer) && (*op + (length>>8) + (1 + LASTLITERALS) > oend)) return 1;   /* Check output limit */
-    if (length>=(int)ML_MASK) { *token+=ML_MASK; length-=ML_MASK; for(; length > 509 ; length-=510) { *(*op)++ = 255; *(*op)++ = 255; } if (length > 254) { length-=255; *(*op)++ = 255; } *(*op)++ = (BYTE)length; }
-    else *token += (BYTE)(length);
+    length = (size_t)(matchLength - MINMATCH);
+    if ((limit) && (*op + (length >> 8) + (1 + LASTLITERALS) > oend)) return 1;   /* Check output limit */
+    if (length >= ML_MASK) {
+        *token += ML_MASK;
+        length -= ML_MASK;
+        for(; length >= 510 ; length -= 510) { *(*op)++ = 255; *(*op)++ = 255; }
+        if (length >= 255) { length -= 255; *(*op)++ = 255; }
+        *(*op)++ = (BYTE)length;
+    } else {
+        *token += (BYTE)(length);
+    }
 
     /* Prepare next loop */
     *ip += matchLength;
@@ -330,49 +304,54 @@ FORCE_INLINE int LZ4HC_encodeSequence (
     return 0;
 }
 
+/* btopt */
+#include "lz4opt.h"
 
-static int LZ4HC_compress_generic (
-    void* ctxvoid,
-    const char* source,
-    char* dest,
-    int inputSize,
-    int maxOutputSize,
-    int compressionLevel,
+
+static int LZ4HC_compress_hashChain (
+    LZ4HC_CCtx_internal* const ctx,
+    const char* const source,
+    char* const dest,
+    int* srcSizePtr,
+    int const maxOutputSize,
+    unsigned maxNbAttempts,
     limitedOutput_directive limit
     )
 {
-    LZ4HC_Data_Structure* ctx = (LZ4HC_Data_Structure*) ctxvoid;
+    const int inputSize = *srcSizePtr;
+
     const BYTE* ip = (const BYTE*) source;
     const BYTE* anchor = ip;
     const BYTE* const iend = ip + inputSize;
     const BYTE* const mflimit = iend - MFLIMIT;
     const BYTE* const matchlimit = (iend - LASTLITERALS);
 
+    BYTE* optr = (BYTE*) dest;
     BYTE* op = (BYTE*) dest;
-    BYTE* const oend = op + maxOutputSize;
+    BYTE* oend = op + maxOutputSize;
 
-    unsigned maxNbAttempts;
     int   ml, ml2, ml3, ml0;
-    const BYTE* ref=NULL;
-    const BYTE* start2=NULL;
-    const BYTE* ref2=NULL;
-    const BYTE* start3=NULL;
-    const BYTE* ref3=NULL;
+    const BYTE* ref = NULL;
+    const BYTE* start2 = NULL;
+    const BYTE* ref2 = NULL;
+    const BYTE* start3 = NULL;
+    const BYTE* ref3 = NULL;
     const BYTE* start0;
     const BYTE* ref0;
 
-
     /* init */
-    if (compressionLevel > g_maxCompressionLevel) compressionLevel = g_maxCompressionLevel;
-    if (compressionLevel < 1) compressionLevel = LZ4HC_compressionLevel_default;
-    maxNbAttempts = 1 << (compressionLevel-1);
+    *srcSizePtr = 0;
+    if (limit == limitedDestSize && maxOutputSize < 1) return 0;         /* Impossible to store anything */
+    if ((U32)inputSize > (U32)LZ4_MAX_INPUT_SIZE) return 0;              /* Unsupported input size, too large (or negative) */
+
     ctx->end += inputSize;
+    if (limit == limitedDestSize) oend -= LASTLITERALS;                  /* Hack for support limitations LZ4 decompressor */
+    if (inputSize < LZ4_minLength) goto _last_literals;                  /* Input too small, no compression (all literals) */
 
     ip++;
 
     /* Main Loop */
-    while (ip < mflimit)
-    {
+    while (ip < mflimit) {
         ml = LZ4HC_InsertAndFindBestMatch (ctx, ip, matchlimit, (&ref), maxNbAttempts);
         if (!ml) { ip++; continue; }
 
@@ -383,19 +362,18 @@ static int LZ4HC_compress_generic (
 
 _Search2:
         if (ip+ml < mflimit)
-            ml2 = LZ4HC_InsertAndGetWiderMatch(ctx, ip + ml - 2, ip + 1, matchlimit, ml, &ref2, &start2, maxNbAttempts);
-        else ml2 = ml;
+            ml2 = LZ4HC_InsertAndGetWiderMatch(ctx, ip + ml - 2, ip + 0, matchlimit, ml, &ref2, &start2, maxNbAttempts);
+        else
+            ml2 = ml;
 
-        if (ml2 == ml)  /* No better match */
-        {
-            if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) return 0;
+        if (ml2 == ml) { /* No better match */
+            optr = op;
+            if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) goto _dest_overflow;
             continue;
         }
 
-        if (start0 < ip)
-        {
-            if (start2 < ip + ml0)   /* empirical */
-            {
+        if (start0 < ip) {
+            if (start2 < ip + ml0) {  /* empirical */
                 ip = start0;
                 ref = ref0;
                 ml = ml0;
@@ -403,8 +381,7 @@ _Search2:
         }
 
         /* Here, start0==ip */
-        if ((start2 - ip) < 3)   /* First Match too small : removed */
-        {
+        if ((start2 - ip) < 3) {  /* First Match too small : removed */
             ml = ml2;
             ip = start2;
             ref =ref2;
@@ -412,20 +389,16 @@ _Search2:
         }
 
 _Search3:
-        /*
-        * Currently we have :
-        * ml2 > ml1, and
-        * ip1+3 <= ip2 (usually < ip1+ml1)
-        */
-        if ((start2 - ip) < OPTIMAL_ML)
-        {
+        /* At this stage, we have :
+        *  ml2 > ml1, and
+        *  ip1+3 <= ip2 (usually < ip1+ml1) */
+        if ((start2 - ip) < OPTIMAL_ML) {
             int correction;
             int new_ml = ml;
             if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;
             if (ip+new_ml > start2 + ml2 - MINMATCH) new_ml = (int)(start2 - ip) + ml2 - MINMATCH;
             correction = new_ml - (int)(start2 - ip);
-            if (correction > 0)
-            {
+            if (correction > 0) {
                 start2 += correction;
                 ref2 += correction;
                 ml2 -= correction;
@@ -435,38 +408,37 @@ _Search3:
 
         if (start2 + ml2 < mflimit)
             ml3 = LZ4HC_InsertAndGetWiderMatch(ctx, start2 + ml2 - 3, start2, matchlimit, ml2, &ref3, &start3, maxNbAttempts);
-        else ml3 = ml2;
+        else
+            ml3 = ml2;
 
-        if (ml3 == ml2) /* No better match : 2 sequences to encode */
-        {
+        if (ml3 == ml2) {  /* No better match : 2 sequences to encode */
             /* ip & ref are known; Now for ml */
             if (start2 < ip+ml)  ml = (int)(start2 - ip);
             /* Now, encode 2 sequences */
-            if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) return 0;
+            optr = op;
+            if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) goto _dest_overflow;
             ip = start2;
-            if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml2, ref2, limit, oend)) return 0;
+            optr = op;
+            if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml2, ref2, limit, oend)) goto _dest_overflow;
             continue;
         }
 
-        if (start3 < ip+ml+3) /* Not enough space for match 2 : remove it */
-        {
-            if (start3 >= (ip+ml)) /* can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 */
-            {
-                if (start2 < ip+ml)
-                {
+        if (start3 < ip+ml+3) {  /* Not enough space for match 2 : remove it */
+            if (start3 >= (ip+ml)) {  /* can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 */
+                if (start2 < ip+ml) {
                     int correction = (int)(ip+ml - start2);
                     start2 += correction;
                     ref2 += correction;
                     ml2 -= correction;
-                    if (ml2 < MINMATCH)
-                    {
+                    if (ml2 < MINMATCH) {
                         start2 = start3;
                         ref2 = ref3;
                         ml2 = ml3;
                     }
                 }
 
-                if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) return 0;
+                optr = op;
+                if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) goto _dest_overflow;
                 ip  = start3;
                 ref = ref3;
                 ml  = ml3;
@@ -487,27 +459,23 @@ _Search3:
         * OK, now we have 3 ascending matches; let's write at least the first one
         * ip & ref are known; Now for ml
         */
-        if (start2 < ip+ml)
-        {
-            if ((start2 - ip) < (int)ML_MASK)
-            {
+        if (start2 < ip+ml) {
+            if ((start2 - ip) < (int)ML_MASK) {
                 int correction;
                 if (ml > OPTIMAL_ML) ml = OPTIMAL_ML;
                 if (ip + ml > start2 + ml2 - MINMATCH) ml = (int)(start2 - ip) + ml2 - MINMATCH;
                 correction = ml - (int)(start2 - ip);
-                if (correction > 0)
-                {
+                if (correction > 0) {
                     start2 += correction;
                     ref2 += correction;
                     ml2 -= correction;
                 }
-            }
-            else
-            {
+            } else {
                 ml = (int)(start2 - ip);
             }
         }
-        if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) return 0;
+        optr = op;
+        if (LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ref, limit, oend)) goto _dest_overflow;
 
         ip = start2;
         ref = ref2;
@@ -520,37 +488,121 @@ _Search3:
         goto _Search3;
     }
 
+_last_literals:
     /* Encode Last Literals */
-    {
-        int lastRun = (int)(iend - anchor);
-        if ((limit) && (((char*)op - dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize)) return 0;  /* Check output limit */
-        if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }
-        else *op++ = (BYTE)(lastRun<<ML_BITS);
-        memcpy(op, anchor, iend - anchor);
-        op += iend-anchor;
+    {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
+        size_t litLength = (lastRunSize + 255 - RUN_MASK) / 255;
+        size_t const totalSize = 1 + litLength + lastRunSize;
+        if (limit == limitedDestSize) oend += LASTLITERALS;  /* restore correct value */
+        if (limit && (op + totalSize > oend)) {
+            if (limit == limitedOutput) return 0;  /* Check output limit */
+            /* adapt lastRunSize to fill 'dest' */
+            lastRunSize  = (size_t)(oend - op) - 1;
+            litLength = (lastRunSize + 255 - RUN_MASK) / 255;
+            lastRunSize -= litLength;
+        }
+        ip = anchor + lastRunSize;
+
+        if (lastRunSize >= RUN_MASK) {
+            size_t accumulator = lastRunSize - RUN_MASK;
+            *op++ = (RUN_MASK << ML_BITS);
+            for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;
+            *op++ = (BYTE) accumulator;
+        } else {
+            *op++ = (BYTE)(lastRunSize << ML_BITS);
+        }
+        memcpy(op, anchor, lastRunSize);
+        op += lastRunSize;
     }
 
     /* End */
+    *srcSizePtr = (int) (((const char*)ip) - source);
     return (int) (((char*)op)-dest);
+
+_dest_overflow:
+    if (limit == limitedDestSize) {
+        op = optr;  /* restore correct out pointer */
+        goto _last_literals;
+    }
+    return 0;
+}
+
+static int LZ4HC_getSearchNum(int compressionLevel)
+{
+    switch (compressionLevel) {
+        default: return 0; /* unused */
+        case 11: return 128;
+        case 12: return 1<<10;
+    }
+}
+
+static int LZ4HC_compress_generic (
+    LZ4HC_CCtx_internal* const ctx,
+    const char* const src,
+    char* const dst,
+    int* const srcSizePtr,
+    int const dstCapacity,
+    int cLevel,
+    limitedOutput_directive limit
+    )
+{
+    if (cLevel < 1) cLevel = LZ4HC_CLEVEL_DEFAULT;   /* note : convention is different from lz4frame, maybe to reconsider */
+    if (cLevel > 9) {
+        if (limit == limitedDestSize) cLevel = 10;
+        switch (cLevel) {
+            case 10:
+                return LZ4HC_compress_hashChain(ctx, src, dst, srcSizePtr, dstCapacity, 1 << 12, limit);
+            case 11:
+                ctx->searchNum = LZ4HC_getSearchNum(cLevel);
+                return LZ4HC_compress_optimal(ctx, src, dst, *srcSizePtr, dstCapacity, limit, 128, 0);
+            default:
+                cLevel = 12;
+                /* fall-through */
+            case 12:
+                ctx->searchNum = LZ4HC_getSearchNum(cLevel);
+                return LZ4HC_compress_optimal(ctx, src, dst, *srcSizePtr, dstCapacity, limit, LZ4_OPT_NUM, 1);
+        }
+    }
+    return LZ4HC_compress_hashChain(ctx, src, dst, srcSizePtr, dstCapacity, 1 << (cLevel-1), limit);  /* levels 1-9 */
 }
 
 
-int LZ4_sizeofStateHC(void) { return sizeof(LZ4HC_Data_Structure); }
+int LZ4_sizeofStateHC(void) { return sizeof(LZ4_streamHC_t); }
 
-int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel)
+int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
 {
+    LZ4HC_CCtx_internal* const ctx = &((LZ4_streamHC_t*)state)->internal_donotuse;
     if (((size_t)(state)&(sizeof(void*)-1)) != 0) return 0;   /* Error : state is not aligned for pointers (32 or 64 bits) */
-    LZ4HC_init ((LZ4HC_Data_Structure*)state, (const BYTE*)src);
-    if (maxDstSize < LZ4_compressBound(srcSize))
-        return LZ4HC_compress_generic (state, src, dst, srcSize, maxDstSize, compressionLevel, limitedOutput);
+    LZ4HC_init (ctx, (const BYTE*)src);
+    if (dstCapacity < LZ4_compressBound(srcSize))
+        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, limitedOutput);
     else
-        return LZ4HC_compress_generic (state, src, dst, srcSize, maxDstSize, compressionLevel, noLimit);
+        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, noLimit);
 }
 
-int LZ4_compress_HC(const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel)
+int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
 {
-    LZ4HC_Data_Structure state;
-    return LZ4_compress_HC_extStateHC(&state, src, dst, srcSize, maxDstSize, compressionLevel);
+#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
+    LZ4_streamHC_t* const statePtr = (LZ4_streamHC_t*)malloc(sizeof(LZ4_streamHC_t));
+#else
+    LZ4_streamHC_t state;
+    LZ4_streamHC_t* const statePtr = &state;
+#endif
+    int const cSize = LZ4_compress_HC_extStateHC(statePtr, src, dst, srcSize, dstCapacity, compressionLevel);
+#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
+    free(statePtr);
+#endif
+    return cSize;
+}
+
+/* LZ4_compress_HC_destSize() :
+ * currently, only compatible with Hash Chain implementation,
+ * hence limit compression level to LZ4HC_CLEVEL_OPT_MIN-1*/
+int LZ4_compress_HC_destSize(void* LZ4HC_Data, const char* source, char* dest, int* sourceSizePtr, int targetDestSize, int cLevel)
+{
+    LZ4HC_CCtx_internal* const ctx = &((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse;
+    LZ4HC_init(ctx, (const BYTE*) source);
+    return LZ4HC_compress_generic(ctx, source, dest, sourceSizePtr, targetDestSize, cLevel, limitedDestSize);
 }
 
 
@@ -560,38 +612,59 @@ int LZ4_compress_HC(const char* src, char* dst, int srcSize, int maxDstSize, int
 **************************************/
 /* allocation */
 LZ4_streamHC_t* LZ4_createStreamHC(void) { return (LZ4_streamHC_t*)malloc(sizeof(LZ4_streamHC_t)); }
-int             LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr) { free(LZ4_streamHCPtr); return 0; }
+int             LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr) {
+    if (!LZ4_streamHCPtr) return 0;  /* support free on NULL */
+    free(LZ4_streamHCPtr);
+    return 0;
+}
 
 
 /* initialization */
 void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
 {
-    LZ4_STATIC_ASSERT(sizeof(LZ4HC_Data_Structure) <= sizeof(LZ4_streamHC_t));   /* if compilation fails here, LZ4_STREAMHCSIZE must be increased */
-    ((LZ4HC_Data_Structure*)LZ4_streamHCPtr)->base = NULL;
-    ((LZ4HC_Data_Structure*)LZ4_streamHCPtr)->compressionLevel = (unsigned)compressionLevel;
+    LZ4_STATIC_ASSERT(sizeof(LZ4HC_CCtx_internal) <= sizeof(size_t) * LZ4_STREAMHCSIZE_SIZET);   /* if compilation fails here, LZ4_STREAMHCSIZE must be increased */
+    LZ4_streamHCPtr->internal_donotuse.base = NULL;
+    if (compressionLevel > LZ4HC_CLEVEL_MAX) compressionLevel = LZ4HC_CLEVEL_MAX;  /* cap compression level */
+    LZ4_streamHCPtr->internal_donotuse.compressionLevel = compressionLevel;
+    LZ4_streamHCPtr->internal_donotuse.searchNum = LZ4HC_getSearchNum(compressionLevel);
+}
+
+void LZ4_setCompressionLevel(LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
+{
+    int const currentCLevel = LZ4_streamHCPtr->internal_donotuse.compressionLevel;
+    int const minCLevel = currentCLevel < LZ4HC_CLEVEL_OPT_MIN ? 1 : LZ4HC_CLEVEL_OPT_MIN;
+    int const maxCLevel = currentCLevel < LZ4HC_CLEVEL_OPT_MIN ? LZ4HC_CLEVEL_OPT_MIN-1 : LZ4HC_CLEVEL_MAX;
+    compressionLevel = MIN(compressionLevel, minCLevel);
+    compressionLevel = MAX(compressionLevel, maxCLevel);
+    LZ4_streamHCPtr->internal_donotuse.compressionLevel = compressionLevel;
 }
 
 int LZ4_loadDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, const char* dictionary, int dictSize)
 {
-    LZ4HC_Data_Structure* ctxPtr = (LZ4HC_Data_Structure*) LZ4_streamHCPtr;
-    if (dictSize > 64 KB)
-    {
+    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
+    if (dictSize > 64 KB) {
         dictionary += dictSize - 64 KB;
         dictSize = 64 KB;
     }
     LZ4HC_init (ctxPtr, (const BYTE*)dictionary);
-    if (dictSize >= 4) LZ4HC_Insert (ctxPtr, (const BYTE*)dictionary +(dictSize-3));
     ctxPtr->end = (const BYTE*)dictionary + dictSize;
+    if (ctxPtr->compressionLevel >= LZ4HC_CLEVEL_OPT_MIN)
+        LZ4HC_updateBinTree(ctxPtr, ctxPtr->end - MFLIMIT, ctxPtr->end - LASTLITERALS);
+    else
+        if (dictSize >= 4) LZ4HC_Insert (ctxPtr, ctxPtr->end-3);
     return dictSize;
 }
 
 
 /* compression */
 
-static void LZ4HC_setExternalDict(LZ4HC_Data_Structure* ctxPtr, const BYTE* newBlock)
+static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock)
 {
-    if (ctxPtr->end >= ctxPtr->base + 4)
-        LZ4HC_Insert (ctxPtr, ctxPtr->end-3);   /* Referencing remaining dictionary content */
+    if (ctxPtr->compressionLevel >= LZ4HC_CLEVEL_OPT_MIN)
+        LZ4HC_updateBinTree(ctxPtr, ctxPtr->end - MFLIMIT, ctxPtr->end - LASTLITERALS);
+    else
+        if (ctxPtr->end >= ctxPtr->base + 4) LZ4HC_Insert (ctxPtr, ctxPtr->end-3);   /* Referencing remaining dictionary content */
+
     /* Only one memory segment for extDict, so any previous extDict is lost at this stage */
     ctxPtr->lowLimit  = ctxPtr->dictLimit;
     ctxPtr->dictLimit = (U32)(ctxPtr->end - ctxPtr->base);
@@ -601,64 +674,67 @@ static void LZ4HC_setExternalDict(LZ4HC_Data_Structure* ctxPtr, const BYTE* newB
     ctxPtr->nextToUpdate = ctxPtr->dictLimit;   /* match referencing will resume from there */
 }
 
-static int LZ4_compressHC_continue_generic (LZ4HC_Data_Structure* ctxPtr,
-                                            const char* source, char* dest,
-                                            int inputSize, int maxOutputSize, limitedOutput_directive limit)
+static int LZ4_compressHC_continue_generic (LZ4_streamHC_t* LZ4_streamHCPtr,
+                                            const char* src, char* dst,
+                                            int* srcSizePtr, int dstCapacity,
+                                            limitedOutput_directive limit)
 {
+    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
     /* auto-init if forgotten */
-    if (ctxPtr->base == NULL)
-        LZ4HC_init (ctxPtr, (const BYTE*) source);
+    if (ctxPtr->base == NULL) LZ4HC_init (ctxPtr, (const BYTE*) src);
 
     /* Check overflow */
-    if ((size_t)(ctxPtr->end - ctxPtr->base) > 2 GB)
-    {
+    if ((size_t)(ctxPtr->end - ctxPtr->base) > 2 GB) {
         size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->base) - ctxPtr->dictLimit;
         if (dictSize > 64 KB) dictSize = 64 KB;
-
-        LZ4_loadDictHC((LZ4_streamHC_t*)ctxPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize);
+        LZ4_loadDictHC(LZ4_streamHCPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize);
     }
 
     /* Check if blocks follow each other */
-    if ((const BYTE*)source != ctxPtr->end)
-        LZ4HC_setExternalDict(ctxPtr, (const BYTE*)source);
+    if ((const BYTE*)src != ctxPtr->end) LZ4HC_setExternalDict(ctxPtr, (const BYTE*)src);
 
     /* Check overlapping input/dictionary space */
-    {
-        const BYTE* sourceEnd = (const BYTE*) source + inputSize;
-        const BYTE* dictBegin = ctxPtr->dictBase + ctxPtr->lowLimit;
-        const BYTE* dictEnd   = ctxPtr->dictBase + ctxPtr->dictLimit;
-        if ((sourceEnd > dictBegin) && ((const BYTE*)source < dictEnd))
-        {
+    {   const BYTE* sourceEnd = (const BYTE*) src + *srcSizePtr;
+        const BYTE* const dictBegin = ctxPtr->dictBase + ctxPtr->lowLimit;
+        const BYTE* const dictEnd   = ctxPtr->dictBase + ctxPtr->dictLimit;
+        if ((sourceEnd > dictBegin) && ((const BYTE*)src < dictEnd)) {
             if (sourceEnd > dictEnd) sourceEnd = dictEnd;
             ctxPtr->lowLimit = (U32)(sourceEnd - ctxPtr->dictBase);
             if (ctxPtr->dictLimit - ctxPtr->lowLimit < 4) ctxPtr->lowLimit = ctxPtr->dictLimit;
         }
     }
 
-    return LZ4HC_compress_generic (ctxPtr, source, dest, inputSize, maxOutputSize, ctxPtr->compressionLevel, limit);
+    return LZ4HC_compress_generic (ctxPtr, src, dst, srcSizePtr, dstCapacity, ctxPtr->compressionLevel, limit);
 }
 
-int LZ4_compress_HC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize, int maxOutputSize)
+int LZ4_compress_HC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int srcSize, int dstCapacity)
 {
-    if (maxOutputSize < LZ4_compressBound(inputSize))
-        return LZ4_compressHC_continue_generic ((LZ4HC_Data_Structure*)LZ4_streamHCPtr, source, dest, inputSize, maxOutputSize, limitedOutput);
+    if (dstCapacity < LZ4_compressBound(srcSize))
+        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, limitedOutput);
     else
-        return LZ4_compressHC_continue_generic ((LZ4HC_Data_Structure*)LZ4_streamHCPtr, source, dest, inputSize, maxOutputSize, noLimit);
+        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, noLimit);
 }
 
+int LZ4_compress_HC_continue_destSize (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int* srcSizePtr, int targetDestSize)
+{
+    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
+    if (ctxPtr->compressionLevel >= LZ4HC_CLEVEL_OPT_MIN) LZ4HC_init(ctxPtr, (const BYTE*)src);   /* not compatible with btopt implementation */
+    return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, srcSizePtr, targetDestSize, limitedDestSize);
+}
+
+
 
 /* dictionary saving */
 
 int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictSize)
 {
-    LZ4HC_Data_Structure* streamPtr = (LZ4HC_Data_Structure*)LZ4_streamHCPtr;
-    int prefixSize = (int)(streamPtr->end - (streamPtr->base + streamPtr->dictLimit));
+    LZ4HC_CCtx_internal* const streamPtr = &LZ4_streamHCPtr->internal_donotuse;
+    int const prefixSize = (int)(streamPtr->end - (streamPtr->base + streamPtr->dictLimit));
     if (dictSize > 64 KB) dictSize = 64 KB;
     if (dictSize < 4) dictSize = 0;
     if (dictSize > prefixSize) dictSize = prefixSize;
     memmove(safeBuffer, streamPtr->end - dictSize, dictSize);
-    {
-        U32 endIndex = (U32)(streamPtr->end - streamPtr->base);
+    {   U32 const endIndex = (U32)(streamPtr->end - streamPtr->base);
         streamPtr->end = (const BYTE*)safeBuffer + dictSize;
         streamPtr->base = streamPtr->end - endIndex;
         streamPtr->dictLimit = endIndex - dictSize;
@@ -672,8 +748,8 @@ int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictS
 /***********************************
 *  Deprecated Functions
 ***********************************/
+/* These functions currently generate deprecation warnings */
 /* Deprecated compression functions */
-/* These functions are planned to start generate warnings by r131 approximately */
 int LZ4_compressHC(const char* src, char* dst, int srcSize) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), 0); }
 int LZ4_compressHC_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, 0); }
 int LZ4_compressHC2(const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); }
@@ -687,44 +763,45 @@ int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* ctx, const char* src,
 
 
 /* Deprecated streaming functions */
-/* These functions currently generate deprecation warnings */
 int LZ4_sizeofStreamStateHC(void) { return LZ4_STREAMHCSIZE; }
 
 int LZ4_resetStreamStateHC(void* state, char* inputBuffer)
 {
+    LZ4HC_CCtx_internal *ctx = &((LZ4_streamHC_t*)state)->internal_donotuse;
     if ((((size_t)state) & (sizeof(void*)-1)) != 0) return 1;   /* Error : pointer is not aligned for pointer (32 or 64 bits) */
-    LZ4HC_init((LZ4HC_Data_Structure*)state, (const BYTE*)inputBuffer);
-    ((LZ4HC_Data_Structure*)state)->inputBuffer = (BYTE*)inputBuffer;
+    LZ4HC_init(ctx, (const BYTE*)inputBuffer);
+    ctx->inputBuffer = (BYTE*)inputBuffer;
     return 0;
 }
 
 void* LZ4_createHC (char* inputBuffer)
 {
-    void* hc4 = ALLOCATOR(1, sizeof(LZ4HC_Data_Structure));
-    LZ4HC_init ((LZ4HC_Data_Structure*)hc4, (const BYTE*)inputBuffer);
-    ((LZ4HC_Data_Structure*)hc4)->inputBuffer = (BYTE*)inputBuffer;
+    LZ4_streamHC_t* hc4 = (LZ4_streamHC_t*)ALLOCATOR(1, sizeof(LZ4_streamHC_t));
+    if (hc4 == NULL) return NULL;   /* not enough memory */
+    LZ4HC_init (&hc4->internal_donotuse, (const BYTE*)inputBuffer);
+    hc4->internal_donotuse.inputBuffer = (BYTE*)inputBuffer;
     return hc4;
 }
 
-int LZ4_freeHC (void* LZ4HC_Data)
-{
+int LZ4_freeHC (void* LZ4HC_Data) {
+    if (!LZ4HC_Data) return 0;  /* support free on NULL */
     FREEMEM(LZ4HC_Data);
-    return (0);
+    return 0;
 }
 
-int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel)
+int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int cLevel)
 {
-    return LZ4HC_compress_generic (LZ4HC_Data, source, dest, inputSize, 0, compressionLevel, noLimit);
+    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, 0, cLevel, noLimit);
 }
 
-int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel)
+int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int dstCapacity, int cLevel)
 {
-    return LZ4HC_compress_generic (LZ4HC_Data, source, dest, inputSize, maxOutputSize, compressionLevel, limitedOutput);
+    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, dstCapacity, cLevel, limitedOutput);
 }
 
 char* LZ4_slideInputBufferHC(void* LZ4HC_Data)
 {
-    LZ4HC_Data_Structure* hc4 = (LZ4HC_Data_Structure*)LZ4HC_Data;
-    int dictSize = LZ4_saveDictHC((LZ4_streamHC_t*)LZ4HC_Data, (char*)(hc4->inputBuffer), 64 KB);
+    LZ4HC_CCtx_internal* const hc4 = &((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse;
+    int const dictSize = LZ4_saveDictHC((LZ4_streamHC_t*)LZ4HC_Data, (char*)(hc4->inputBuffer), 64 KB);
     return (char*)(hc4->inputBuffer + dictSize);
 }

src/lz4/lib/lz4hc.h

@@ -1,7 +1,7 @@
 /*
    LZ4 HC - High Compression Mode of LZ4
    Header File
-   Copyright (C) 2011-2015, Yann Collet.
+   Copyright (C) 2011-2017, Yann Collet.
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
    Redistribution and use in source and binary forms, with or without
@@ -28,162 +28,251 @@
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
    You can contact the author at :
-   - LZ4 source repository : https://github.com/Cyan4973/lz4
+   - LZ4 source repository : https://github.com/lz4/lz4
    - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
 */
-#pragma once
-
+#ifndef LZ4_HC_H_19834876238432
+#define LZ4_HC_H_19834876238432
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
-/*****************************
-*  Includes
-*****************************/
-#include <stddef.h>   /* size_t */
+/* --- Dependency --- */
+/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */
+#include "lz4.h"   /* stddef, LZ4LIB_API, LZ4_DEPRECATED */
 
 
-/**************************************
-*  Block Compression
-**************************************/
-int LZ4_compress_HC (const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel);
-/*
-LZ4_compress_HC :
-    Destination buffer 'dst' must be already allocated.
-    Compression completion is guaranteed if 'dst' buffer is sized to handle worst circumstances (data not compressible)
-    Worst size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
-      srcSize  : Max supported value is LZ4_MAX_INPUT_SIZE (see "lz4.h")
-      compressionLevel : Recommended values are between 4 and 9, although any value between 0 and 16 will work.
-                         0 means "use default value" (see lz4hc.c).
-                         Values >16 behave the same as 16.
-      return : the number of bytes written into buffer 'dst'
-            or 0 if compression fails.
-*/
+/* --- Useful constants --- */
+#define LZ4HC_CLEVEL_MIN         3
+#define LZ4HC_CLEVEL_DEFAULT     9
+#define LZ4HC_CLEVEL_OPT_MIN    11
+#define LZ4HC_CLEVEL_MAX        12
+
+
+/*-************************************
+ *  Block Compression
+ **************************************/
+/*! LZ4_compress_HC() :
+ * Compress data from `src` into `dst`, using the more powerful but slower "HC" algorithm.
+ * `dst` must be already allocated.
+ * Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h")
+ * Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h")
+ * `compressionLevel` : Recommended values are between 4 and 9, although any value between 1 and LZ4HC_CLEVEL_MAX will work.
+ *                      Values >LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX.
+ * @return : the number of bytes written into 'dst'
+ *           or 0 if compression fails.
+ */
+LZ4LIB_API int LZ4_compress_HC (const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel);
 
 
 /* Note :
-   Decompression functions are provided within LZ4 source code (see "lz4.h") (BSD license)
-*/
+ *   Decompression functions are provided within "lz4.h" (BSD license)
+ */
 
 
-int LZ4_sizeofStateHC(void);
-int LZ4_compress_HC_extStateHC(void* state, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel);
-/*
-LZ4_compress_HC_extStateHC() :
-   Use this function if you prefer to manually allocate memory for compression tables.
-   To know how much memory must be allocated for the compression tables, use :
-      int LZ4_sizeofStateHC();
-
-   Allocated memory must be aligned on 8-bytes boundaries (which a normal malloc() will do properly).
-
-   The allocated memory can then be provided to the compression functions using 'void* state' parameter.
-   LZ4_compress_HC_extStateHC() is equivalent to previously described function.
-   It just uses externally allocated memory for stateHC.
-*/
+/*! LZ4_compress_HC_extStateHC() :
+ * Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`.
+ * `state` size is provided by LZ4_sizeofStateHC().
+ * Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() will do properly).
+ */
+LZ4LIB_API int LZ4_compress_HC_extStateHC(void* state, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel);
+LZ4LIB_API int LZ4_sizeofStateHC(void);
 
 
-/**************************************
-*  Streaming Compression
-**************************************/
-#define LZ4_STREAMHCSIZE        262192
-#define LZ4_STREAMHCSIZE_SIZET (LZ4_STREAMHCSIZE / sizeof(size_t))
-typedef struct { size_t table[LZ4_STREAMHCSIZE_SIZET]; } LZ4_streamHC_t;
-/*
-  LZ4_streamHC_t
-  This structure allows static allocation of LZ4 HC streaming state.
-  State must then be initialized using LZ4_resetStreamHC() before first use.
+/*-************************************
+ *  Streaming Compression
+ *  Bufferless synchronous API
+ **************************************/
+ typedef union LZ4_streamHC_u LZ4_streamHC_t;   /* incomplete type (defined later) */
 
-  Static allocation should only be used in combination with static linking.
-  If you want to use LZ4 as a DLL, please use construction functions below, which are future-proof.
-*/
+/*! LZ4_createStreamHC() and LZ4_freeStreamHC() :
+ * These functions create and release memory for LZ4 HC streaming state.
+ * Newly created states are automatically initialized.
+ * Existing states can be re-used several times, using LZ4_resetStreamHC().
+ * These methods are API and ABI stable, they can be used in combination with a DLL.
+ */
+LZ4LIB_API LZ4_streamHC_t* LZ4_createStreamHC(void);
+LZ4LIB_API int             LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr);
 
+LZ4LIB_API void LZ4_resetStreamHC (LZ4_streamHC_t* streamHCPtr, int compressionLevel);
+LZ4LIB_API int  LZ4_loadDictHC (LZ4_streamHC_t* streamHCPtr, const char* dictionary, int dictSize);
 
-LZ4_streamHC_t* LZ4_createStreamHC(void);
-int             LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr);
-/*
-  These functions create and release memory for LZ4 HC streaming state.
-  Newly created states are already initialized.
-  Existing state space can be re-used anytime using LZ4_resetStreamHC().
-  If you use LZ4 as a DLL, use these functions instead of static structure allocation,
-  to avoid size mismatch between different versions.
-*/
+LZ4LIB_API int LZ4_compress_HC_continue (LZ4_streamHC_t* streamHCPtr, const char* src, char* dst, int srcSize, int maxDstSize);
 
-void LZ4_resetStreamHC (LZ4_streamHC_t* streamHCPtr, int compressionLevel);
-int  LZ4_loadDictHC (LZ4_streamHC_t* streamHCPtr, const char* dictionary, int dictSize);
-
-int LZ4_compress_HC_continue (LZ4_streamHC_t* streamHCPtr, const char* src, char* dst, int srcSize, int maxDstSize);
-
-int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize);
+LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize);
 
 /*
   These functions compress data in successive blocks of any size, using previous blocks as dictionary.
   One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks.
-  There is an exception for ring buffers, which can be smaller 64 KB.
-  Such case is automatically detected and correctly handled by LZ4_compress_HC_continue().
+  There is an exception for ring buffers, which can be smaller than 64 KB.
+  Ring buffers scenario is automatically detected and handled by LZ4_compress_HC_continue().
 
   Before starting compression, state must be properly initialized, using LZ4_resetStreamHC().
   A first "fictional block" can then be designated as initial dictionary, using LZ4_loadDictHC() (Optional).
 
   Then, use LZ4_compress_HC_continue() to compress each successive block.
-  It works like LZ4_compress_HC(), but use previous memory blocks as dictionary to improve compression.
   Previous memory blocks (including initial dictionary when present) must remain accessible and unmodified during compression.
-  As a reminder, size 'dst' buffer to handle worst cases, using LZ4_compressBound(), to ensure success of compression operation.
+  'dst' buffer should be sized to handle worst case scenarios (see LZ4_compressBound()), to ensure operation success.
+  Because in case of failure, the API does not guarantee context recovery, and context will have to be reset.
+  If `dst` buffer budget cannot be >= LZ4_compressBound(), consider using LZ4_compress_HC_continue_destSize() instead.
 
-  If, for any reason, previous data blocks can't be preserved unmodified in memory during next compression block,
-  you must save it to a safer memory space, using LZ4_saveDictHC().
+  If, for any reason, previous data block can't be preserved unmodified in memory for next compression block,
+  you can save it to a more stable memory space, using LZ4_saveDictHC().
   Return value of LZ4_saveDictHC() is the size of dictionary effectively saved into 'safeBuffer'.
 */
 
 
+ /*-*************************************
+ * PRIVATE DEFINITIONS :
+ * Do not use these definitions.
+ * They are exposed to allow static allocation of `LZ4_streamHC_t`.
+ * Using these definitions makes the code vulnerable to potential API break when upgrading LZ4
+ **************************************/
+#define LZ4HC_DICTIONARY_LOGSIZE 17   /* because of btopt, hc would only need 16 */
+#define LZ4HC_MAXD (1<<LZ4HC_DICTIONARY_LOGSIZE)
+#define LZ4HC_MAXD_MASK (LZ4HC_MAXD - 1)
 
-/**************************************
+#define LZ4HC_HASH_LOG 15
+#define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG)
+#define LZ4HC_HASH_MASK (LZ4HC_HASHTABLESIZE - 1)
+
+
+#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#include <stdint.h>
+
+typedef struct
+{
+    uint32_t   hashTable[LZ4HC_HASHTABLESIZE];
+    uint16_t   chainTable[LZ4HC_MAXD];
+    const uint8_t* end;         /* next block here to continue on current prefix */
+    const uint8_t* base;        /* All index relative to this position */
+    const uint8_t* dictBase;    /* alternate base for extDict */
+    uint8_t* inputBuffer;       /* deprecated */
+    uint32_t   dictLimit;       /* below that point, need extDict */
+    uint32_t   lowLimit;        /* below that point, no more dict */
+    uint32_t   nextToUpdate;    /* index from which to continue dictionary update */
+    uint32_t   searchNum;       /* only for optimal parser */
+    uint32_t   compressionLevel;
+} LZ4HC_CCtx_internal;
+
+#else
+
+typedef struct
+{
+    unsigned int   hashTable[LZ4HC_HASHTABLESIZE];
+    unsigned short chainTable[LZ4HC_MAXD];
+    const unsigned char* end;        /* next block here to continue on current prefix */
+    const unsigned char* base;       /* All index relative to this position */
+    const unsigned char* dictBase;   /* alternate base for extDict */
+    unsigned char* inputBuffer;      /* deprecated */
+    unsigned int   dictLimit;        /* below that point, need extDict */
+    unsigned int   lowLimit;         /* below that point, no more dict */
+    unsigned int   nextToUpdate;     /* index from which to continue dictionary update */
+    unsigned int   searchNum;        /* only for optimal parser */
+    int            compressionLevel;
+} LZ4HC_CCtx_internal;
+
+#endif
+
+#define LZ4_STREAMHCSIZE       (4*LZ4HC_HASHTABLESIZE + 2*LZ4HC_MAXD + 56) /* 393268 */
+#define LZ4_STREAMHCSIZE_SIZET (LZ4_STREAMHCSIZE / sizeof(size_t))
+union LZ4_streamHC_u {
+    size_t table[LZ4_STREAMHCSIZE_SIZET];
+    LZ4HC_CCtx_internal internal_donotuse;
+};   /* previously typedef'd to LZ4_streamHC_t */
+/*
+  LZ4_streamHC_t :
+  This structure allows static allocation of LZ4 HC streaming state.
+  State must be initialized using LZ4_resetStreamHC() before first use.
+
+  Static allocation shall only be used in combination with static linking.
+  When invoking LZ4 from a DLL, use create/free functions instead, which are API and ABI stable.
+*/
+
+
+/*-************************************
 *  Deprecated Functions
 **************************************/
-/* Deprecate Warnings */
-/* Should these warnings messages be a problem,
-   it is generally possible to disable them,
-   with -Wno-deprecated-declarations for gcc
-   or _CRT_SECURE_NO_WARNINGS in Visual for example.
-   You can also define LZ4_DEPRECATE_WARNING_DEFBLOCK. */
-#ifndef LZ4_DEPRECATE_WARNING_DEFBLOCK
-#  define LZ4_DEPRECATE_WARNING_DEFBLOCK
-#  define LZ4_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-#  if (LZ4_GCC_VERSION >= 405) || defined(__clang__)
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
-#  elif (LZ4_GCC_VERSION >= 301)
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
-#  elif defined(_MSC_VER)
-#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
-#  else
-#    pragma message("WARNING: You need to implement LZ4_DEPRECATED for this compiler")
-#    define LZ4_DEPRECATED(message)
-#  endif
-#endif // LZ4_DEPRECATE_WARNING_DEFBLOCK
+/* see lz4.h LZ4_DISABLE_DEPRECATE_WARNINGS to turn off deprecation warnings */
 
-/* compression functions */
-/* these functions are planned to trigger warning messages by r131 approximately */
-int LZ4_compressHC                (const char* source, char* dest, int inputSize);
-int LZ4_compressHC_limitedOutput  (const char* source, char* dest, int inputSize, int maxOutputSize);
-int LZ4_compressHC2               (const char* source, char* dest, int inputSize, int compressionLevel);
-int LZ4_compressHC2_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-int LZ4_compressHC_withStateHC               (void* state, const char* source, char* dest, int inputSize);
-int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-int LZ4_compressHC2_withStateHC              (void* state, const char* source, char* dest, int inputSize, int compressionLevel);
-int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-int LZ4_compressHC_continue               (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize);
-int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
+/* deprecated compression functions */
+/* these functions will trigger warning messages in future releases */
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC() instead") int LZ4_compressHC               (const char* source, char* dest, int inputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC() instead") int LZ4_compressHC_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC() instead") int LZ4_compressHC2 (const char* source, char* dest, int inputSize, int compressionLevel);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC() instead") int LZ4_compressHC2_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") int LZ4_compressHC_withStateHC               (void* state, const char* source, char* dest, int inputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") int LZ4_compressHC2_withStateHC (void* state, const char* source, char* dest, int inputSize, int compressionLevel);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") int LZ4_compressHC_continue               (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
 
-/* Streaming functions following the older model; should no longer be used */
-LZ4_DEPRECATED("use LZ4_createStreamHC() instead") void* LZ4_createHC (char* inputBuffer);
-LZ4_DEPRECATED("use LZ4_saveDictHC() instead")     char* LZ4_slideInputBufferHC (void* LZ4HC_Data);
-LZ4_DEPRECATED("use LZ4_freeStreamHC() instead")   int   LZ4_freeHC (void* LZ4HC_Data);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") int   LZ4_compressHC2_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") int   LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_createStreamHC() instead") int   LZ4_sizeofStreamStateHC(void);
-LZ4_DEPRECATED("use LZ4_resetStreamHC() instead")  int   LZ4_resetStreamStateHC(void* state, char* inputBuffer);
+/* Deprecated Streaming functions using older model; should no longer be used */
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStreamHC() instead") void* LZ4_createHC (char* inputBuffer);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_saveDictHC() instead")     char* LZ4_slideInputBufferHC (void* LZ4HC_Data);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_freeStreamHC() instead")   int   LZ4_freeHC (void* LZ4HC_Data);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_createStreamHC() instead") int   LZ4_sizeofStreamStateHC(void);
+LZ4LIB_API LZ4_DEPRECATED("use LZ4_resetStreamHC() instead")  int   LZ4_resetStreamStateHC(void* state, char* inputBuffer);
 
 
 #if defined (__cplusplus)
 }
 #endif
+
+#endif /* LZ4_HC_H_19834876238432 */
+
+/*-************************************************
+ * !!!!!     STATIC LINKING ONLY     !!!!!
+ * Following definitions are considered experimental.
+ * They should not be linked from DLL,
+ * as there is no guarantee of API stability yet.
+ * Prototypes will be promoted to "stable" status
+ * after successfull usage in real-life scenarios.
+ *************************************************/
+#ifdef LZ4_HC_STATIC_LINKING_ONLY   /* protection macro */
+#ifndef LZ4_HC_SLO_098092834
+#define LZ4_HC_SLO_098092834
+
+/*! LZ4_compress_HC_destSize() : v1.8.0 (experimental)
+ *  Will try to compress as much data from `src` as possible
+ *  that can fit into `targetDstSize` budget.
+ *  Result is provided in 2 parts :
+ * @return : the number of bytes written into 'dst'
+ *           or 0 if compression fails.
+ * `srcSizePtr` : value will be updated to indicate how much bytes were read from `src`
+ */
+int LZ4_compress_HC_destSize(void* LZ4HC_Data,
+                            const char* src, char* dst,
+                            int* srcSizePtr, int targetDstSize,
+                            int compressionLevel);
+
+/*! LZ4_compress_HC_continue_destSize() : v1.8.0 (experimental)
+ *  Similar as LZ4_compress_HC_continue(),
+ *  but will read a variable nb of bytes from `src`
+ *  to fit into `targetDstSize` budget.
+ *  Result is provided in 2 parts :
+ * @return : the number of bytes written into 'dst'
+ *           or 0 if compression fails.
+ * `srcSizePtr` : value will be updated to indicate how much bytes were read from `src`.
+ *  Important : due to limitations, this prototype only works well up to cLevel < LZ4HC_CLEVEL_OPT_MIN
+ *              beyond that level, compression performance will be much reduced due to internal incompatibilities
+ */
+int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t* LZ4_streamHCPtr,
+                            const char* src, char* dst,
+                            int* srcSizePtr, int targetDstSize);
+
+/*! LZ4_setCompressionLevel() : v1.8.0 (experimental)
+ *  It's possible to change compression level after LZ4_resetStreamHC(), between 2 invocations of LZ4_compress_HC_continue*(),
+ *  but that requires to stay in the same mode (aka 1-10 or 11-12).
+ *  This function ensures this condition.
+ */
+void LZ4_setCompressionLevel(LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel);
+
+
+
+#endif   /* LZ4_HC_SLO_098092834 */
+#endif   /* LZ4_HC_STATIC_LINKING_ONLY */

src/lz4/lib/lz4opt.h

@@ -0,0 +1,366 @@
+/*
+    lz4opt.h - Optimal Mode of LZ4
+    Copyright (C) 2015-2017, Przemyslaw Skibinski <inikep@gmail.com>
+    Note : this file is intended to be included within lz4hc.c
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+       - LZ4 source repository : https://github.com/lz4/lz4
+       - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+
+#define LZ4_OPT_NUM   (1<<12)
+
+
+typedef struct {
+    int off;
+    int len;
+} LZ4HC_match_t;
+
+typedef struct {
+    int price;
+    int off;
+    int mlen;
+    int litlen;
+} LZ4HC_optimal_t;
+
+
+/* price in bytes */
+FORCE_INLINE size_t LZ4HC_literalsPrice(size_t litlen)
+{
+    size_t price = litlen;
+    if (litlen >= (size_t)RUN_MASK)
+        price += 1 + (litlen-RUN_MASK)/255;
+    return price;
+}
+
+
+/* requires mlen >= MINMATCH */
+FORCE_INLINE size_t LZ4HC_sequencePrice(size_t litlen, size_t mlen)
+{
+    size_t price = 2 + 1; /* 16-bit offset + token */
+
+    price += LZ4HC_literalsPrice(litlen);
+
+    if (mlen >= (size_t)(ML_MASK+MINMATCH))
+        price+= 1 + (mlen-(ML_MASK+MINMATCH))/255;
+
+    return price;
+}
+
+
+/*-*************************************
+*  Binary Tree search
+***************************************/
+FORCE_INLINE int LZ4HC_BinTree_InsertAndGetAllMatches (
+    LZ4HC_CCtx_internal* ctx,
+    const BYTE* const ip,
+    const BYTE* const iHighLimit,
+    size_t best_mlen,
+    LZ4HC_match_t* matches,
+    int* matchNum)
+{
+    U16* const chainTable = ctx->chainTable;
+    U32* const HashTable = ctx->hashTable;
+    const BYTE* const base = ctx->base;
+    const U32 dictLimit = ctx->dictLimit;
+    const U32 current = (U32)(ip - base);
+    const U32 lowLimit = (ctx->lowLimit + MAX_DISTANCE > current) ? ctx->lowLimit : current - (MAX_DISTANCE - 1);
+    const BYTE* const dictBase = ctx->dictBase;
+    const BYTE* match;
+    int nbAttempts = ctx->searchNum;
+    int mnum = 0;
+    U16 *ptr0, *ptr1, delta0, delta1;
+    U32 matchIndex;
+    size_t matchLength = 0;
+    U32* HashPos;
+
+    if (ip + MINMATCH > iHighLimit) return 1;
+
+    /* HC4 match finder */
+    HashPos = &HashTable[LZ4HC_hashPtr(ip)];
+    matchIndex = *HashPos;
+    *HashPos = current;
+
+    ptr0 = &DELTANEXTMAXD(current*2+1);
+    ptr1 = &DELTANEXTMAXD(current*2);
+    delta0 = delta1 = (U16)(current - matchIndex);
+
+    while ((matchIndex < current) && (matchIndex>=lowLimit) && (nbAttempts)) {
+        nbAttempts--;
+        if (matchIndex >= dictLimit) {
+            match = base + matchIndex;
+            matchLength = LZ4_count(ip, match, iHighLimit);
+        } else {
+            const BYTE* vLimit = ip + (dictLimit - matchIndex);
+            match = dictBase + matchIndex;
+            if (vLimit > iHighLimit) vLimit = iHighLimit;
+            matchLength = LZ4_count(ip, match, vLimit);
+            if ((ip+matchLength == vLimit) && (vLimit < iHighLimit))
+                matchLength += LZ4_count(ip+matchLength, base+dictLimit, iHighLimit);
+            if (matchIndex+matchLength >= dictLimit)
+                match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */
+        }
+
+        if (matchLength > best_mlen) {
+            best_mlen = matchLength;
+            if (matches) {
+                if (matchIndex >= dictLimit)
+                    matches[mnum].off = (int)(ip - match);
+                else
+                    matches[mnum].off = (int)(ip - (base + matchIndex)); /* virtual matchpos */
+                matches[mnum].len = (int)matchLength;
+                mnum++;
+            }
+            if (best_mlen > LZ4_OPT_NUM) break;
+        }
+
+        if (ip+matchLength >= iHighLimit)   /* equal : no way to know if inf or sup */
+            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt the tree */
+
+        DEBUGLOG(6, "ip   :%016llX", (U64)ip);
+        DEBUGLOG(6, "match:%016llX", (U64)match);
+        if (*(ip+matchLength) < *(match+matchLength)) {
+            *ptr0 = delta0;
+            ptr0 = &DELTANEXTMAXD(matchIndex*2);
+            if (*ptr0 == (U16)-1) break;
+            delta0 = *ptr0;
+            delta1 += delta0;
+            matchIndex -= delta0;
+        } else {
+            *ptr1 = delta1;
+            ptr1 = &DELTANEXTMAXD(matchIndex*2+1);
+            if (*ptr1 == (U16)-1) break;
+            delta1 = *ptr1;
+            delta0 += delta1;
+            matchIndex -= delta1;
+        }
+    }
+
+    *ptr0 = (U16)-1;
+    *ptr1 = (U16)-1;
+    if (matchNum) *matchNum = mnum;
+  /*  if (best_mlen > 8) return best_mlen-8; */
+    if (!matchNum) return 1;
+    return 1;
+}
+
+
+FORCE_INLINE void LZ4HC_updateBinTree(LZ4HC_CCtx_internal* ctx, const BYTE* const ip, const BYTE* const iHighLimit)
+{
+    const BYTE* const base = ctx->base;
+    const U32 target = (U32)(ip - base);
+    U32 idx = ctx->nextToUpdate;
+    while(idx < target)
+        idx += LZ4HC_BinTree_InsertAndGetAllMatches(ctx, base+idx, iHighLimit, 8, NULL, NULL);
+}
+
+
+/** Tree updater, providing best match */
+FORCE_INLINE int LZ4HC_BinTree_GetAllMatches (
+                        LZ4HC_CCtx_internal* ctx,
+                        const BYTE* const ip, const BYTE* const iHighLimit,
+                        size_t best_mlen, LZ4HC_match_t* matches, const int fullUpdate)
+{
+    int mnum = 0;
+    if (ip < ctx->base + ctx->nextToUpdate) return 0;   /* skipped area */
+    if (fullUpdate) LZ4HC_updateBinTree(ctx, ip, iHighLimit);
+    best_mlen = LZ4HC_BinTree_InsertAndGetAllMatches(ctx, ip, iHighLimit, best_mlen, matches, &mnum);
+    ctx->nextToUpdate = (U32)(ip - ctx->base + best_mlen);
+    return mnum;
+}
+
+
+#define SET_PRICE(pos, ml, offset, ll, cost)           \
+{                                                      \
+    while (last_pos < pos)  { opt[last_pos+1].price = 1<<30; last_pos++; } \
+    opt[pos].mlen = (int)ml;                           \
+    opt[pos].off = (int)offset;                        \
+    opt[pos].litlen = (int)ll;                         \
+    opt[pos].price = (int)cost;                        \
+}
+
+
+static int LZ4HC_compress_optimal (
+    LZ4HC_CCtx_internal* ctx,
+    const char* const source,
+    char* dest,
+    int inputSize,
+    int maxOutputSize,
+    limitedOutput_directive limit,
+    size_t sufficient_len,
+    const int fullUpdate
+    )
+{
+    LZ4HC_optimal_t opt[LZ4_OPT_NUM + 1];   /* this uses a bit too much stack memory to my taste ... */
+    LZ4HC_match_t matches[LZ4_OPT_NUM + 1];
+
+    const BYTE* ip = (const BYTE*) source;
+    const BYTE* anchor = ip;
+    const BYTE* const iend = ip + inputSize;
+    const BYTE* const mflimit = iend - MFLIMIT;
+    const BYTE* const matchlimit = (iend - LASTLITERALS);
+    BYTE* op = (BYTE*) dest;
+    BYTE* const oend = op + maxOutputSize;
+
+    /* init */
+    DEBUGLOG(5, "LZ4HC_compress_optimal");
+    if (sufficient_len >= LZ4_OPT_NUM) sufficient_len = LZ4_OPT_NUM-1;
+    ctx->end += inputSize;
+    ip++;
+
+    /* Main Loop */
+    while (ip < mflimit) {
+        size_t const llen = ip - anchor;
+        size_t last_pos = 0;
+        size_t match_num, cur, best_mlen, best_off;
+        memset(opt, 0, sizeof(LZ4HC_optimal_t));  /* memset only the first one */
+
+        match_num = LZ4HC_BinTree_GetAllMatches(ctx, ip, matchlimit, MINMATCH-1, matches, fullUpdate);
+        if (!match_num) { ip++; continue; }
+
+        if ((size_t)matches[match_num-1].len > sufficient_len) {
+            /* good enough solution : immediate encoding */
+            best_mlen = matches[match_num-1].len;
+            best_off = matches[match_num-1].off;
+            cur = 0;
+            last_pos = 1;
+            goto encode;
+        }
+
+        /* set prices using matches at position = 0 */
+        {   size_t matchNb;
+            for (matchNb = 0; matchNb < match_num; matchNb++) {
+                size_t mlen = (matchNb>0) ? (size_t)matches[matchNb-1].len+1 : MINMATCH;
+                best_mlen = matches[matchNb].len;   /* necessarily < sufficient_len < LZ4_OPT_NUM */
+                for ( ; mlen <= best_mlen ; mlen++) {
+                    size_t const cost = LZ4HC_sequencePrice(llen, mlen) - LZ4HC_literalsPrice(llen);
+                    SET_PRICE(mlen, mlen, matches[matchNb].off, 0, cost);   /* updates last_pos and opt[pos] */
+        }   }   }
+
+        if (last_pos < MINMATCH) { ip++; continue; }  /* note : on clang at least, this test improves performance */
+
+        /* check further positions */
+        opt[0].mlen = opt[1].mlen = 1;
+        for (cur = 1; cur <= last_pos; cur++) {
+            const BYTE* const curPtr = ip + cur;
+
+            /* establish baseline price if cur is literal */
+            {   size_t price, litlen;
+                if (opt[cur-1].mlen == 1) {
+                    /* no match at previous position */
+                    litlen = opt[cur-1].litlen + 1;
+                    if (cur > litlen) {
+                        price = opt[cur - litlen].price + LZ4HC_literalsPrice(litlen);
+                    } else {
+                        price = LZ4HC_literalsPrice(llen + litlen) - LZ4HC_literalsPrice(llen);
+                    }
+                } else {
+                    litlen = 1;
+                    price = opt[cur - 1].price + LZ4HC_literalsPrice(1);
+                }
+
+                if (price < (size_t)opt[cur].price)
+                    SET_PRICE(cur, 1 /*mlen*/, 0 /*off*/, litlen, price);   /* note : increases last_pos */
+            }
+
+            if (cur == last_pos || curPtr >= mflimit) break;
+
+            match_num = LZ4HC_BinTree_GetAllMatches(ctx, curPtr, matchlimit, MINMATCH-1, matches, fullUpdate);
+            if ((match_num > 0) && (size_t)matches[match_num-1].len > sufficient_len) {
+                /* immediate encoding */
+                best_mlen = matches[match_num-1].len;
+                best_off = matches[match_num-1].off;
+                last_pos = cur + 1;
+                goto encode;
+            }
+
+            /* set prices using matches at position = cur */
+            {   size_t matchNb;
+                for (matchNb = 0; matchNb < match_num; matchNb++) {
+                    size_t ml = (matchNb>0) ? (size_t)matches[matchNb-1].len+1 : MINMATCH;
+                    best_mlen = (cur + matches[matchNb].len < LZ4_OPT_NUM) ?
+                                (size_t)matches[matchNb].len : LZ4_OPT_NUM - cur;
+
+                    for ( ; ml <= best_mlen ; ml++) {
+                        size_t ll, price;
+                        if (opt[cur].mlen == 1) {
+                            ll = opt[cur].litlen;
+                            if (cur > ll)
+                                price = opt[cur - ll].price + LZ4HC_sequencePrice(ll, ml);
+                            else
+                                price = LZ4HC_sequencePrice(llen + ll, ml) - LZ4HC_literalsPrice(llen);
+                        } else {
+                            ll = 0;
+                            price = opt[cur].price + LZ4HC_sequencePrice(0, ml);
+                        }
+
+                        if (cur + ml > last_pos || price < (size_t)opt[cur + ml].price) {
+                            SET_PRICE(cur + ml, ml, matches[matchNb].off, ll, price);
+            }   }   }   }
+        } /* for (cur = 1; cur <= last_pos; cur++) */
+
+        best_mlen = opt[last_pos].mlen;
+        best_off = opt[last_pos].off;
+        cur = last_pos - best_mlen;
+
+encode: /* cur, last_pos, best_mlen, best_off must be set */
+        opt[0].mlen = 1;
+        while (1) {  /* from end to beginning */
+            size_t const ml = opt[cur].mlen;
+            int const offset = opt[cur].off;
+            opt[cur].mlen = (int)best_mlen;
+            opt[cur].off = (int)best_off;
+            best_mlen = ml;
+            best_off = offset;
+            if (ml > cur) break;   /* can this happen ? */
+            cur -= ml;
+        }
+
+        /* encode all recorded sequences */
+        cur = 0;
+        while (cur < last_pos) {
+            int const ml = opt[cur].mlen;
+            int const offset = opt[cur].off;
+            if (ml == 1) { ip++; cur++; continue; }
+            cur += ml;
+            if ( LZ4HC_encodeSequence(&ip, &op, &anchor, ml, ip - offset, limit, oend) ) return 0;
+        }
+    }  /* while (ip < mflimit) */
+
+    /* Encode Last Literals */
+    {   int lastRun = (int)(iend - anchor);
+        if ((limit) && (((char*)op - dest) + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > (U32)maxOutputSize)) return 0;  /* Check output limit */
+        if (lastRun>=(int)RUN_MASK) { *op++=(RUN_MASK<<ML_BITS); lastRun-=RUN_MASK; for(; lastRun > 254 ; lastRun-=255) *op++ = 255; *op++ = (BYTE) lastRun; }
+        else *op++ = (BYTE)(lastRun<<ML_BITS);
+        memcpy(op, anchor, iend - anchor);
+        op += iend-anchor;
+    }
+
+    /* End */
+    return (int) ((char*)op-dest);
+}

src/lz4/lib/xxhash.h

@@ -1,7 +1,7 @@
 /*
    xxHash - Extremely Fast Hash algorithm
    Header File
-   Copyright (C) 2012-2015, Yann Collet.
+   Copyright (C) 2012-2016, Yann Collet.
 
    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
 
@@ -64,96 +64,230 @@ XXH64       13.8 GB/s            1.9 GB/s
 XXH32        6.8 GB/s            6.0 GB/s
 */
 
-#pragma once
+#ifndef XXHASH_H_5627135585666179
+#define XXHASH_H_5627135585666179 1
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
 
-/*****************************
+/* ****************************
 *  Definitions
-*****************************/
+******************************/
 #include <stddef.h>   /* size_t */
 typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
 
 
+/* ****************************
+*  API modifier
+******************************/
+/** XXH_PRIVATE_API
+*   This is useful to include xxhash functions in `static` mode
+*   in order to inline them, and remove their symbol from the public list.
+*   Methodology :
+*     #define XXH_PRIVATE_API
+*     #include "xxhash.h"
+*   `xxhash.c` is automatically included.
+*   It's not useful to compile and link it as a separate module.
+*/
+#ifdef XXH_PRIVATE_API
+#  ifndef XXH_STATIC_LINKING_ONLY
+#    define XXH_STATIC_LINKING_ONLY
+#  endif
+#  if defined(__GNUC__)
+#    define XXH_PUBLIC_API static __inline __attribute__((unused))
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#    define XXH_PUBLIC_API static inline
+#  elif defined(_MSC_VER)
+#    define XXH_PUBLIC_API static __inline
+#  else
+#    define XXH_PUBLIC_API static   /* this version may generate warnings for unused static functions; disable the relevant warning */
+#  endif
+#else
+#  define XXH_PUBLIC_API   /* do nothing */
+#endif /* XXH_PRIVATE_API */
 
-/*****************************
-*  Simple Hash Functions
-*****************************/
+/*!XXH_NAMESPACE, aka Namespace Emulation :
 
-unsigned int       XXH32 (const void* input, size_t length, unsigned seed);
-unsigned long long XXH64 (const void* input, size_t length, unsigned long long seed);
+If you want to include _and expose_ xxHash functions from within your own library,
+but also want to avoid symbol collisions with other libraries which may also include xxHash,
 
-/*
-XXH32() :
+you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
+with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
+
+Note that no change is required within the calling program as long as it includes `xxhash.h` :
+regular symbol name will be automatically translated by this header.
+*/
+#ifdef XXH_NAMESPACE
+#  define XXH_CAT(A,B) A##B
+#  define XXH_NAME2(A,B) XXH_CAT(A,B)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
+#endif
+
+
+/* *************************************
+*  Version
+***************************************/
+#define XXH_VERSION_MAJOR    0
+#define XXH_VERSION_MINOR    6
+#define XXH_VERSION_RELEASE  2
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+
+
+/*-**********************************************************************
+*  32-bits hash
+************************************************************************/
+typedef unsigned int       XXH32_hash_t;
+
+/*! XXH32() :
     Calculate the 32-bits hash of sequence "length" bytes stored at memory address "input".
     The memory between input & input+length must be valid (allocated and read-accessible).
     "seed" can be used to alter the result predictably.
-    This function successfully passes all SMHasher tests.
-    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s
-XXH64() :
-    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
-    Faster on 64-bits systems. Slower on 32-bits systems.
-*/
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
 
+/*======   Streaming   ======*/
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
 
-
-/*****************************
-*  Advanced Hash Functions
-*****************************/
-typedef struct { long long ll[ 6]; } XXH32_state_t;
-typedef struct { long long ll[11]; } XXH64_state_t;
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
 
 /*
-These structures allow static allocation of XXH states.
-States must then be initialized using XXHnn_reset() before first use.
+These functions generate the xxHash of an input provided in multiple segments.
+Note that, for small input, they are slower than single-call functions, due to state management.
+For small input, prefer `XXH32()` and `XXH64()` .
 
-If you prefer dynamic allocation, please refer to functions below.
-*/
+XXH state must first be allocated, using XXH*_createState() .
 
-XXH32_state_t* XXH32_createState(void);
-XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+Start a new hash by initializing state with a seed, using XXH*_reset().
 
-XXH64_state_t* XXH64_createState(void);
-XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
-
-/*
-These functions create and release memory for XXH state.
-States must then be initialized using XXHnn_reset() before first use.
-*/
-
-
-XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned seed);
-XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
-unsigned int  XXH32_digest (const XXH32_state_t* statePtr);
-
-XXH_errorcode      XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
-XXH_errorcode      XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
-unsigned long long XXH64_digest (const XXH64_state_t* statePtr);
-
-/*
-These functions calculate the xxHash of an input provided in multiple smaller packets,
-as opposed to an input provided as a single block.
-
-XXH state space must first be allocated, using either static or dynamic method provided above.
-
-Start a new hash by initializing state with a seed, using XXHnn_reset().
-
-Then, feed the hash state by calling XXHnn_update() as many times as necessary.
-Obviously, input must be valid, meaning allocated and read accessible.
+Then, feed the hash state by calling XXH*_update() as many times as necessary.
+Obviously, input must be allocated and read accessible.
 The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
 
-Finally, you can produce a hash anytime, by using XXHnn_digest().
-This function returns the final nn-bits hash.
-You can nonetheless continue feeding the hash state with more input,
-and therefore get some new hashes, by calling again XXHnn_digest().
+Finally, a hash value can be produced anytime, by using XXH*_digest().
+This function returns the nn-bits hash as an int or long long.
 
-When you are done, don't forget to free XXH state space, using typically XXHnn_freeState().
+It's still possible to continue inserting input into the hash state after a digest,
+and generate some new hashes later on, by calling again XXH*_digest().
+
+When done, free XXH state space if it was allocated dynamically.
 */
 
+/*======   Canonical representation   ======*/
+
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
+
+/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
+*  The canonical representation uses human-readable write convention, aka big-endian (large digits first).
+*  These functions allow transformation of hash result into and from its canonical format.
+*  This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
+*/
+
+
+#ifndef XXH_NO_LONG_LONG
+/*-**********************************************************************
+*  64-bits hash
+************************************************************************/
+typedef unsigned long long XXH64_hash_t;
+
+/*! XXH64() :
+    Calculate the 64-bits hash of sequence of length "len" stored at memory address "input".
+    "seed" can be used to alter the result predictably.
+    This function runs faster on 64-bits systems, but slower on 32-bits systems (see benchmark).
+*/
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
+
+/*======   Streaming   ======*/
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
+
+/*======   Canonical representation   ======*/
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+#endif  /* XXH_NO_LONG_LONG */
+
+
+#ifdef XXH_STATIC_LINKING_ONLY
+
+/* ================================================================================================
+   This section contains definitions which are not guaranteed to remain stable.
+   They may change in future versions, becoming incompatible with a different version of the library.
+   They shall only be used with static linking.
+   Never use these definitions in association with dynamic linking !
+=================================================================================================== */
+
+/* These definitions are only meant to allow allocation of XXH state
+   statically, on stack, or in a struct for example.
+   Do not use members directly. */
+
+   struct XXH32_state_s {
+       unsigned total_len_32;
+       unsigned large_len;
+       unsigned v1;
+       unsigned v2;
+       unsigned v3;
+       unsigned v4;
+       unsigned mem32[4];   /* buffer defined as U32 for alignment */
+       unsigned memsize;
+       unsigned reserved;   /* never read nor write, will be removed in a future version */
+   };   /* typedef'd to XXH32_state_t */
+
+#ifndef XXH_NO_LONG_LONG
+   struct XXH64_state_s {
+       unsigned long long total_len;
+       unsigned long long v1;
+       unsigned long long v2;
+       unsigned long long v3;
+       unsigned long long v4;
+       unsigned long long mem64[4];   /* buffer defined as U64 for alignment */
+       unsigned memsize;
+       unsigned reserved[2];          /* never read nor write, will be removed in a future version */
+   };   /* typedef'd to XXH64_state_t */
+#endif
+
+#  ifdef XXH_PRIVATE_API
+#    include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
+#  endif
+
+#endif /* XXH_STATIC_LINKING_ONLY */
+
 
 #if defined (__cplusplus)
 }
 #endif
+
+#endif /* XXHASH_H_5627135585666179 */

src/lz4/programs/.gitignore

@@ -0,0 +1,20 @@
+# local binary (Makefile)
+lz4
+unlz4
+lz4cat
+lz4c
+lz4c32
+datagen
+frametest
+frametest32
+fullbench
+fullbench32
+fuzzer
+fuzzer32
+*.exe
+
+# tests files
+tmp*
+
+# artefacts
+*.dSYM

src/lz4/programs/Makefile

@@ -1,6 +1,8 @@
 # ##########################################################################
 # LZ4 programs - Makefile
-# Copyright (C) Yann Collet 2011-2015
+# Copyright (C) Yann Collet 2011-2016
+#
+# This Makefile is validated for Linux, macOS, *BSD, Hurd, Solaris, MSYS2 targets
 #
 # GPL v2 License
 #
@@ -19,293 +21,152 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 # You can contact the author at :
+#  - LZ4 homepage : http://www.lz4.org
 #  - LZ4 source repository : https://github.com/Cyan4973/lz4
-#  - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
 # ##########################################################################
 # lz4 : Command Line Utility, supporting gzip-like arguments
 # lz4c  : CLU, supporting also legacy lz4demo arguments
 # lz4c32: Same as lz4c, but forced to compile in 32-bits mode
-# fuzzer  : Test tool, to check lz4 integrity on target platform
-# fuzzer32: Same as fuzzer, but forced to compile in 32-bits mode
-# frametest  : Test tool, to check lz4frame integrity on target platform
-# frametest32: Same as frametest, but forced to compile in 32-bits mode
-# fullbench  : Precisely measure speed for each LZ4 function variant
-# fullbench32: Same as fullbench, but forced to compile in 32-bits mode
-# datagen : generates synthetic data samples for tests & benchmarks
 # ##########################################################################
 
-RELEASE?= r130
+# Version numbers
+LZ4DIR   := ../lib
+LIBVER_SRC := $(LZ4DIR)/lz4.h
+LIBVER_MAJOR_SCRIPT:=`sed -n '/define LZ4_VERSION_MAJOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LIBVER_SRC)`
+LIBVER_MINOR_SCRIPT:=`sed -n '/define LZ4_VERSION_MINOR/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LIBVER_SRC)`
+LIBVER_PATCH_SCRIPT:=`sed -n '/define LZ4_VERSION_RELEASE/s/.*[[:blank:]]\([0-9][0-9]*\).*/\1/p' < $(LIBVER_SRC)`
+LIBVER_SCRIPT:= $(LIBVER_MAJOR_SCRIPT).$(LIBVER_MINOR_SCRIPT).$(LIBVER_PATCH_SCRIPT)
+LIBVER_MAJOR := $(shell echo $(LIBVER_MAJOR_SCRIPT))
+LIBVER_MINOR := $(shell echo $(LIBVER_MINOR_SCRIPT))
+LIBVER_PATCH := $(shell echo $(LIBVER_PATCH_SCRIPT))
+LIBVER   := $(shell echo $(LIBVER_SCRIPT))
 
-DESTDIR?=
-PREFIX ?= /usr/local
-CFLAGS ?= -O3
-CFLAGS += -std=c99 -Wall -Wextra -Wundef -Wshadow -Wcast-qual -Wcast-align -Wstrict-prototypes -pedantic -DLZ4_VERSION=\"$(RELEASE)\"
-FLAGS  := -I../lib $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
+SRCFILES := $(wildcard $(LZ4DIR)/*.c) $(wildcard *.c)
+OBJFILES := $(patsubst %.c,%.o,$(SRCFILES))
 
-BINDIR := $(PREFIX)/bin
-MANDIR := $(PREFIX)/share/man/man1
-LZ4DIR := ../lib
+CPPFLAGS += -I$(LZ4DIR) -DXXH_NAMESPACE=LZ4_
+CFLAGS   ?= -O3
+DEBUGFLAGS:=-Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow \
+           -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes \
+           -Wpointer-arith -Wstrict-aliasing=1
+CFLAGS   += $(DEBUGFLAGS) $(MOREFLAGS)
+FLAGS     = $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)
+
+LZ4_VERSION=$(LIBVER)
+MD2ROFF   = ronn
+MD2ROFF_FLAGS = --roff --warnings --manual="User Commands" --organization="lz4 $(LZ4_VERSION)"
 
 
 # Define *.exe as extension for Windows systems
 ifneq (,$(filter Windows%,$(OS)))
-EXT =.exe
-VOID = nul
+EXT  :=.exe
+VOID := nul
 else
-EXT =
-VOID = /dev/null
+EXT  :=
+VOID := /dev/null
 endif
 
 
-# Select test target for Travis CI's Build Matrix
-TRAVIS_TARGET:= $(LZ4_TRAVIS_CI_ENV)
-TEST_FILES   := COPYING
-TEST_TARGETS := test-native
-FUZZER_TIME  := -T9mn
 
+default: lz4-release
 
-default: lz4
+all: lz4 lz4c
 
-m32: lz4c32 fullbench32 fuzzer32 frametest32
+all32: CFLAGS+=-m32
+all32: all
 
-bins: lz4 lz4c fullbench fuzzer frametest datagen
+lz4: $(OBJFILES)
+	$(CC) $(FLAGS) $^ -o $@$(EXT)
 
-all: bins m32
+lz4-release: DEBUGFLAGS=
+lz4-release: lz4
 
-lz4: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c
-	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+lz4c32: CFLAGS += -m32
+lz4c32 : $(SRCFILES)
+	$(CC) $(FLAGS) $^ -o $@$(EXT)
 
-lz4c  : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c
-	$(CC)      $(FLAGS) -DENABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT)
+lz4c: lz4
+	ln -s lz4 lz4c
 
-lz4c32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c bench.c lz4io.c lz4cli.c
-	$(CC) -m32 $(FLAGS) -DENABLE_LZ4C_LEGACY_OPTIONS $^ -o $@$(EXT)
+lz4.1: lz4.1.md
+	cat $^ | $(MD2ROFF) $(MD2ROFF_FLAGS) | sed -n '/^\.\\\".*/!p' > $@
 
-fullbench  : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c fullbench.c
-	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+man: lz4.1
 
-fullbench32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/lz4frame.c $(LZ4DIR)/xxhash.c fullbench.c
-	$(CC) -m32 $(FLAGS) $^ -o $@$(EXT)
+clean-man:
+	rm lz4.1
 
-fuzzer  : $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c fuzzer.c
-	$(CC)      $(FLAGS) $^ -o $@$(EXT)
-
-fuzzer32: $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c fuzzer.c
-	$(CC) -m32 $(FLAGS) $^ -o $@$(EXT)
-
-frametest: $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c frametest.c
-	$(CC)      $(FLAGS) $^ -o $@$(EXT)
-
-frametest32: $(LZ4DIR)/lz4frame.c $(LZ4DIR)/lz4.c $(LZ4DIR)/lz4hc.c $(LZ4DIR)/xxhash.c frametest.c
-	$(CC) -m32 $(FLAGS) $^ -o $@$(EXT)
-
-datagen : datagen.c datagencli.c
-	$(CC)      $(FLAGS) $^ -o $@$(EXT)
+preview-man: clean-man man
+	man ./lz4.1
 
 clean:
-	@rm -f core *.o *.test tmp* \
-        lz4$(EXT) lz4c$(EXT) lz4c32$(EXT) \
-        fullbench$(EXT) fullbench32$(EXT) \
-        fuzzer$(EXT) fuzzer32$(EXT) \
-        frametest$(EXT) frametest32$(EXT) \
-        datagen$(EXT)
+	@$(MAKE) -C $(LZ4DIR) $@ > $(VOID)
+	@$(RM) core *.o *.test tmp* \
+           lz4$(EXT) lz4c$(EXT) lz4c32$(EXT) unlz4 lz4cat
 	@echo Cleaning completed
 
 
-#------------------------------------------------------------------------
-#make install is validated only for Linux, OSX, kFreeBSD and Hurd targets
-ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU))
+#-----------------------------------------------------------------------------
+# make install is validated only for Linux, OSX, BSD, Hurd and Solaris targets
+#-----------------------------------------------------------------------------
+ifneq (,$(filter $(shell uname),Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD NetBSD DragonFly SunOS))
 
-install: lz4 lz4c
+unlz4: lz4
+	ln -s lz4 unlz4
+
+lz4cat: lz4
+	ln -s lz4 lz4cat
+
+ifneq (,$(filter $(shell uname),SunOS))
+INSTALL ?= ginstall
+else
+INSTALL ?= install
+endif
+
+DESTDIR     ?=
+# directory variables : GNU convention prefers lowercase
+# support both lower and uppercase (BSD), use uppercase in script
+prefix      ?= /usr/local
+PREFIX      ?= $(prefix)
+exec_prefix ?= $(PREFIX)
+bindir      ?= $(exec_prefix)/bin
+BINDIR      ?= $(bindir)
+datarootdir ?= $(PREFIX)/share
+mandir      ?= $(datarootdir)/man
+
+ifneq (,$(filter $(shell uname),OpenBSD FreeBSD NetBSD DragonFly SunOS))
+MANDIR  ?= $(PREFIX)/man/man1
+else
+MANDIR  ?= $(mandir)
+endif
+
+INSTALL_PROGRAM ?= $(INSTALL) -m 755
+INSTALL_DATA    ?= $(INSTALL) -m 644
+
+
+install: lz4$(EXT) lz4c$(EXT)
 	@echo Installing binaries
-	@install -d -m 755 $(DESTDIR)$(BINDIR)/ $(DESTDIR)$(MANDIR)/
-	@install -m 755 lz4 $(DESTDIR)$(BINDIR)/lz4
+	@$(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)/ $(DESTDIR)$(MANDIR)/
+	@$(INSTALL_PROGRAM) lz4 $(DESTDIR)$(BINDIR)/lz4
 	@ln -sf lz4 $(DESTDIR)$(BINDIR)/lz4cat
 	@ln -sf lz4 $(DESTDIR)$(BINDIR)/unlz4
-	@install -m 755 lz4c $(DESTDIR)$(BINDIR)/lz4c
+	@$(INSTALL_PROGRAM) lz4c$(EXT) $(DESTDIR)$(BINDIR)/lz4c
 	@echo Installing man pages
-	@install -m 644 lz4.1 $(DESTDIR)$(MANDIR)/lz4.1
+	@$(INSTALL_DATA) lz4.1 $(DESTDIR)$(MANDIR)/lz4.1
 	@ln -sf lz4.1 $(DESTDIR)$(MANDIR)/lz4c.1
 	@ln -sf lz4.1 $(DESTDIR)$(MANDIR)/lz4cat.1
 	@ln -sf lz4.1 $(DESTDIR)$(MANDIR)/unlz4.1
 	@echo lz4 installation completed
 
 uninstall:
-	rm -f $(DESTDIR)$(BINDIR)/lz4cat
-	rm -f $(DESTDIR)$(BINDIR)/unlz4
-	[ -x $(DESTDIR)$(BINDIR)/lz4 ] && rm -f $(DESTDIR)$(BINDIR)/lz4
-	[ -x $(DESTDIR)$(BINDIR)/lz4c ] && rm -f $(DESTDIR)$(BINDIR)/lz4c
-	[ -f $(DESTDIR)$(MANDIR)/lz4.1 ] && rm -f $(DESTDIR)$(MANDIR)/lz4.1
-	rm -f $(DESTDIR)$(MANDIR)/lz4c.1
-	rm -f $(DESTDIR)$(MANDIR)/lz4cat.1
-	rm -f $(DESTDIR)$(MANDIR)/unlz4.1
+	@$(RM) $(DESTDIR)$(BINDIR)/lz4cat
+	@$(RM) $(DESTDIR)$(BINDIR)/unlz4
+	@$(RM) $(DESTDIR)$(BINDIR)/lz4
+	@$(RM) $(DESTDIR)$(BINDIR)/lz4c
+	@$(RM) $(DESTDIR)$(MANDIR)/lz4.1
+	@$(RM) $(DESTDIR)$(MANDIR)/lz4c.1
+	@$(RM) $(DESTDIR)$(MANDIR)/lz4cat.1
+	@$(RM) $(DESTDIR)$(MANDIR)/unlz4.1
 	@echo lz4 programs successfully uninstalled
 
-test: test-lz4 test-lz4c test-frametest test-fullbench test-fuzzer test-mem
-
-test32: test-lz4c32 test-frametest32 test-fullbench32 test-fuzzer32 test-mem32
-
-test-all: test test32
-
-test-travis: $(TRAVIS_TARGET)
-
-test-lz4-sparse: lz4 datagen
-	@echo "\n ---- test sparse file support ----"
-	./datagen -g5M  -P100 > tmpSrc
-	./lz4 -B4D tmpSrc | ./lz4 -dv --sparse > tmpB4
-	diff -s tmpSrc tmpB4
-	./lz4 -B5D tmpSrc | ./lz4 -dv --sparse > tmpB5
-	diff -s tmpSrc tmpB5
-	./lz4 -B6D tmpSrc | ./lz4 -dv --sparse > tmpB6
-	diff -s tmpSrc tmpB6
-	./lz4 -B7D tmpSrc | ./lz4 -dv --sparse > tmpB7
-	diff -s tmpSrc tmpB7
-	./lz4 tmpSrc | ./lz4 -dv --no-sparse > tmpNoSparse
-	diff -s tmpSrc tmpNoSparse
-	ls -ls tmp*
-	./datagen -s1 -g1200007 -P100 | ./lz4 | ./lz4 -dv --sparse > tmpOdd   # Odd size file (to not finish on an exact nb of blocks)
-	./datagen -s1 -g1200007 -P100 | diff -s - tmpOdd
-	ls -ls tmpOdd
-	@rm tmp*
-	@echo "\n Compatibility with Console :"
-	echo "Hello World 1 !" | ./lz4 | ./lz4 -d -c
-	echo "Hello World 2 !" | ./lz4 | ./lz4 -d | cat
-	echo "Hello World 3 !" | ./lz4 --no-frame-crc | ./lz4 -d -c
-	@echo "\n Compatibility with Append :"
-	./datagen -P100 -g1M > tmp1M
-	cat tmp1M > tmp2M
-	cat tmp1M >> tmp2M
-	./lz4 -B5 -v tmp1M tmpC
-	./lz4 -d -v tmpC tmpR
-	./lz4 -d -v tmpC >> tmpR
-	ls -ls tmp*
-	diff tmp2M tmpR
-	@rm tmp*
-
-
-
-test-lz4-contentSize: lz4 datagen
-	@echo "\n ---- test original size support ----"
-	./datagen -g15M > tmp
-	./lz4 -v tmp | ./lz4 -t
-	./lz4 -v --content-size tmp | ./lz4 -d > tmp2
-	diff -s tmp tmp2
-	# test large size [2-4] GB
-	@./datagen -g3G -P100 | ./lz4 | ./lz4 --decompress --force --sparse - tmp
-	@ls -ls tmp
-	./lz4 --quiet --content-size tmp | ./lz4 --verbose --decompress --force --sparse - tmp2
-	@ls -ls tmp2
-	@rm tmp*
-
-test-lz4-frame-concatenation: lz4 datagen
-	@echo "\n ---- test frame concatenation ----"
-	@echo -n > empty.test
-	@echo hi > nonempty.test
-	cat nonempty.test empty.test nonempty.test > orig.test
-	@./lz4 -zq empty.test > empty.lz4.test
-	@./lz4 -zq nonempty.test > nonempty.lz4.test
-	cat nonempty.lz4.test empty.lz4.test nonempty.lz4.test > concat.lz4.test
-	./lz4 -d concat.lz4.test > result.test
-	sdiff orig.test result.test
-	@rm *.test
-	@echo frame concatenation test completed
-
-test-lz4-multiple: lz4 datagen
-	@echo "\n ---- test multiple files ----"
-	@./datagen -s1        > tmp1 2> $(VOID)
-	@./datagen -s2 -g100K > tmp2 2> $(VOID)
-	@./datagen -s3 -g1M   > tmp3 2> $(VOID)
-	./lz4 -f -m tmp*
-	ls -ls tmp*
-	rm tmp1 tmp2 tmp3
-	./lz4 -df -m *.lz4
-	ls -ls tmp*
-	./lz4 -f -m tmp1 notHere tmp2; echo $$?
-	@rm tmp*
-
-test-lz4-basic: lz4 datagen
-	@echo "\n ---- test lz4 basic compression/decompression ----"
-	./datagen -g0     | ./lz4 -v     | ./lz4 -t
-	./datagen -g16KB  | ./lz4 -9     | ./lz4 -t
-	./datagen -g20KB > tmpSrc
-	./lz4 < tmpSrc | ./lz4 -d > tmpRes
-	diff -q tmpSrc tmpRes
-	./lz4 --no-frame-crc < tmpSrc | ./lz4 -d > tmpRes
-	diff -q tmpSrc tmpRes
-	./datagen         | ./lz4        | ./lz4 -t
-	./datagen -g6M -P99 | ./lz4 -9BD | ./lz4 -t
-	./datagen -g17M   | ./lz4 -9v    | ./lz4 -qt
-	./datagen -g33M   | ./lz4 --no-frame-crc | ./lz4 -t
-	./datagen -g256MB | ./lz4 -vqB4D | ./lz4 -t
-	./datagen -g6GB   | ./lz4 -vqB5D | ./lz4 -qt
-	./datagen -g6GB   | ./lz4 -vq9BD | ./lz4 -qt
-	@rm tmp*
-
-test-lz4: lz4 datagen test-lz4-basic test-lz4-multiple test-lz4-sparse test-lz4-contentSize test-lz4-frame-concatenation
-	@echo "\n ---- test pass-through ----"
-	./datagen | ./lz4 -tf
-
-test-lz4c: lz4c datagen
-	@echo "\n ---- test lz4c version ----"
-	./datagen -g256MB | ./lz4c -l -v    | ./lz4c   -t
-
-test-interop-32-64: lz4 lz4c32 datagen
-	@echo "\n ---- test interoperability 32-bits -vs- 64 bits ----"
-	./datagen -g16KB  | ./lz4c32 -9     | ./lz4    -t
-	./datagen -P10    | ./lz4    -9B4   | ./lz4c32 -t
-	./datagen         | ./lz4c32        | ./lz4    -t
-	./datagen -g1M    | ./lz4    -3B5   | ./lz4c32 -t
-	./datagen -g256MB | ./lz4c32 -vqB4D | ./lz4    -qt
-	./datagen -g1G -P90 | ./lz4         | ./lz4c32 -t
-	./datagen -g6GB   | ./lz4c32 -vq9BD | ./lz4    -qt
-
-test-lz4c32-basic: lz4c32 datagen
-	@echo "\n ---- test lz4c32 32-bits version ----"
-	./datagen -g16KB  | ./lz4c32 -9     | ./lz4c32 -t
-	./datagen         | ./lz4c32        | ./lz4c32 -t
-	./datagen -g256MB | ./lz4c32 -vqB4D | ./lz4c32 -qt
-	./datagen -g6GB   | ./lz4c32 -vqB5D | ./lz4c32 -qt
-
-test-lz4c32: test-lz4c32-basic test-interop-32-64
-
-test-fullbench: fullbench
-	./fullbench --no-prompt $(NB_LOOPS) $(TEST_FILES)
-
-test-fullbench32: fullbench32
-	./fullbench32 --no-prompt $(NB_LOOPS) $(TEST_FILES)
-
-test-fuzzer: fuzzer
-	./fuzzer $(FUZZER_TIME)
-
-test-fuzzer32: fuzzer32
-	./fuzzer32 $(FUZZER_TIME)
-
-test-frametest: frametest
-	./frametest $(FUZZER_TIME)
-
-test-frametest32: frametest32
-	./frametest32 $(FUZZER_TIME)
-
-test-mem: lz4 datagen fuzzer frametest fullbench
-	@echo "\n ---- valgrind tests : memory analyzer ----"
-	valgrind --leak-check=yes --error-exitcode=1 ./datagen -g50M > $(VOID)
-	./datagen -g16KB > tmp
-	valgrind --leak-check=yes --error-exitcode=1 ./lz4 -9 -BD -f tmp $(VOID)
-	./datagen -g16KB -s2 > tmp2
-	./datagen -g16KB -s3 > tmp3
-	valgrind --leak-check=yes --error-exitcode=1 ./lz4 --force --multiple tmp tmp2 tmp3
-	./datagen -g16MB > tmp
-	valgrind --leak-check=yes --error-exitcode=1 ./lz4 -9 -B5D -f tmp tmp2
-	valgrind --leak-check=yes --error-exitcode=1 ./lz4 -t tmp2
-	valgrind --leak-check=yes --error-exitcode=1 ./lz4 -bi1 tmp
-	valgrind --leak-check=yes --error-exitcode=1 ./fullbench -i1 tmp tmp2
-	./datagen -g256MB > tmp
-	valgrind --leak-check=yes --error-exitcode=1 ./lz4 -B4D -f -vq tmp $(VOID)
-	rm tmp*
-	valgrind --leak-check=yes --error-exitcode=1 ./fuzzer -i64 -t1
-	valgrind --leak-check=yes --error-exitcode=1 ./frametest -i256
-
-test-mem32: lz4c32 datagen
-# unfortunately, valgrind doesn't seem to work with non-native binary. If someone knows how to do a valgrind-test on a 32-bits exe with a 64-bits system...
-
 endif

src/lz4/programs/README.md

@@ -0,0 +1,71 @@
+Command Line Interface for LZ4 library
+============================================
+
+Command Line Interface (CLI) can be created using the `make` command without any additional parameters.
+There are also multiple targets that create different variations of CLI:
+- `lz4` : default CLI, with a command line syntax close to gzip
+- `lz4c` : Same as `lz4` with additional support legacy lz4 commands (incompatible with gzip)
+- `lz4c32` : Same as `lz4c`, but forced to compile in 32-bits mode
+
+
+#### Aggregation of parameters
+CLI supports aggregation of parameters i.e. `-b1`, `-e18`, and `-i1` can be joined into `-b1e18i1`.
+
+
+
+#### Benchmark in Command Line Interface
+CLI includes in-memory compression benchmark module for lz4.
+The benchmark is conducted using a given filename.
+The file is read into memory.
+It makes benchmark more precise as it eliminates I/O overhead.
+
+The benchmark measures ratio, compressed size, compression and decompression speed.
+One can select compression levels starting from `-b` and ending with `-e`.
+The `-i` parameter selects a number of seconds used for each of tested levels.
+
+
+
+#### Usage of Command Line Interface
+The full list of commands can be obtained with `-h` or `-H` parameter:
+```
+Usage :
+      lz4 [arg] [input] [output]
+
+input   : a filename
+          with no FILE, or when FILE is - or stdin, read standard input
+Arguments :
+ -1     : Fast compression (default)
+ -9     : High compression
+ -d     : decompression (default for .lz4 extension)
+ -z     : force compression
+ -f     : overwrite output without prompting
+--rm    : remove source file(s) after successful de/compression
+ -h/-H  : display help/long help and exit
+
+Advanced arguments :
+ -V     : display Version number and exit
+ -v     : verbose mode
+ -q     : suppress warnings; specify twice to suppress errors too
+ -c     : force write to standard output, even if it is the console
+ -t     : test compressed file integrity
+ -m     : multiple input files (implies automatic output filenames)
+ -r     : operate recursively on directories (sets also -m)
+ -l     : compress using Legacy format (Linux kernel compression)
+ -B#    : Block size [4-7] (default : 7)
+ -BD    : Block dependency (improve compression ratio)
+--no-frame-crc : disable stream checksum (default:enabled)
+--content-size : compressed frame includes original size (default:not present)
+--[no-]sparse  : sparse mode (default:enabled on file, disabled on stdout)
+Benchmark arguments :
+ -b#    : benchmark file(s), using # compression level (default : 1)
+ -e#    : test all compression levels from -bX to # (default : 1)
+ -i#    : minimum evaluation time in seconds (default : 3s)
+ -B#    : cut file into independent blocks of size # bytes [32+]
+                      or predefined block size [4-7] (default: 7)
+```
+
+#### License
+
+All files in this directory are licensed under GPL-v2.
+See [COPYING](COPYING) for details.
+The text of the license is also included at the top of each source file.

src/lz4/programs/bench.c

@@ -1,6 +1,6 @@
 /*
     bench.c - Demo program to benchmark open-source compression algorithms
-    Copyright (C) Yann Collet 2012-2015
+    Copyright (C) Yann Collet 2012-2016
 
     GPL v2 License
 
@@ -19,42 +19,32 @@
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
     You can contact the author at :
-    - LZ4 source repository : https://github.com/Cyan4973/lz4
-    - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+    - LZ4 homepage : http://www.lz4.org
+    - LZ4 source repository : https://github.com/lz4/lz4
 */
 
-/**************************************
-*  Compiler Options
-***************************************/
-#if defined(_MSC_VER) || defined(_WIN32)
-#  define _CRT_SECURE_NO_WARNINGS
-#  define _CRT_SECURE_NO_DEPRECATE     /* VS2005 */
-#  define BMK_LEGACY_TIMER 1           /* S_ISREG & gettimeofday() are not supported by MSVC */
-#endif
 
-/* Unix Large Files support (>4GB) */
-#define _FILE_OFFSET_BITS 64
-#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */
-#  define _LARGEFILE_SOURCE
-#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */
-#  define _LARGEFILE64_SOURCE
+/*-************************************
+*  Compiler options
+**************************************/
+#ifdef _MSC_VER    /* Visual Studio */
+#  pragma warning(disable : 4127)    /* disable: C4127: conditional expression is constant */
 #endif
 
 
-/**************************************
+/* *************************************
 *  Includes
 ***************************************/
-#include <stdlib.h>      /* malloc */
-#include <stdio.h>       /* fprintf, fopen, ftello64 */
-#include <sys/types.h>   /* stat64 */
-#include <sys/stat.h>    /* stat64 */
+#include "platform.h"    /* Compiler options */
+#include "util.h"        /* UTIL_GetFileSize, UTIL_sleep */
+#include <stdlib.h>      /* malloc, free */
+#include <string.h>      /* memset */
+#include <stdio.h>       /* fprintf, fopen, ftello */
+#include <time.h>        /* clock_t, clock, CLOCKS_PER_SEC */
+
+#include "datagen.h"     /* RDG_genBuffer */
+#include "xxhash.h"
 
-/* Use ftime() if gettimeofday() is not available on your target */
-#if defined(BMK_LEGACY_TIMER)
-#  include <sys/timeb.h>   /* timeb, ftime */
-#else
-#  include <sys/time.h>    /* gettimeofday */
-#endif
 
 #include "lz4.h"
 #define COMPRESSOR0 LZ4_compress_local
@@ -62,134 +52,310 @@ static int LZ4_compress_local(const char* src, char* dst, int srcSize, int dstSi
 #include "lz4hc.h"
 #define COMPRESSOR1 LZ4_compress_HC
 #define DEFAULTCOMPRESSOR COMPRESSOR0
-
-#include "xxhash.h"
+#define LZ4_isError(errcode) (errcode==0)
 
 
-/**************************************
-*  Compiler specifics
-***************************************/
-#if !defined(S_ISREG)
-#  define S_ISREG(x) (((x) & S_IFMT) == S_IFREG)
-#endif
-
-
-/**************************************
-*  Basic Types
-***************************************/
-#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-# include <stdint.h>
-  typedef uint8_t  BYTE;
-  typedef uint16_t U16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-#else
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-#endif
-
-
-/**************************************
+/* *************************************
 *  Constants
 ***************************************/
-#define NBLOOPS    3
-#define TIMELOOP   2000
+#ifndef LZ4_GIT_COMMIT_STRING
+#  define LZ4_GIT_COMMIT_STRING ""
+#else
+#  define LZ4_GIT_COMMIT_STRING LZ4_EXPAND_AND_QUOTE(LZ4_GIT_COMMIT)
+#endif
+
+#define NBSECONDS             3
+#define TIMELOOP_MICROSEC     1*1000000ULL /* 1 second */
+#define ACTIVEPERIOD_MICROSEC 70*1000000ULL /* 70 seconds */
+#define COOLPERIOD_SEC        10
+#define DECOMP_MULT           2 /* test decompression DECOMP_MULT times longer than compression */
 
 #define KB *(1 <<10)
 #define MB *(1 <<20)
 #define GB *(1U<<30)
 
-#define MAX_MEM             (2 GB - 64 MB)
-#define DEFAULT_CHUNKSIZE   (4 MB)
+static const size_t maxMemory = (sizeof(size_t)==4)  ?  (2 GB - 64 MB) : (size_t)(1ULL << ((sizeof(size_t)*8)-31));
+
+static U32 g_compressibilityDefault = 50;
 
 
-/**************************************
-*  Local structures
+/* *************************************
+*  console display
 ***************************************/
-struct chunkParameters
+#define DISPLAY(...)         fprintf(stderr, __VA_ARGS__)
+#define DISPLAYLEVEL(l, ...) if (g_displayLevel>=l) { DISPLAY(__VA_ARGS__); }
+static U32 g_displayLevel = 2;   /* 0 : no display;   1: errors;   2 : + result + interaction + warnings;   3 : + progression;   4 : + information */
+
+#define DISPLAYUPDATE(l, ...) if (g_displayLevel>=l) { \
+            if ((clock() - g_time > refreshRate) || (g_displayLevel>=4)) \
+            { g_time = clock(); DISPLAY(__VA_ARGS__); \
+            if (g_displayLevel>=4) fflush(stdout); } }
+static const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;
+static clock_t g_time = 0;
+
+
+/* *************************************
+*  Exceptions
+***************************************/
+#ifndef DEBUG
+#  define DEBUG 0
+#endif
+#define DEBUGOUTPUT(...) if (DEBUG) DISPLAY(__VA_ARGS__);
+#define EXM_THROW(error, ...)                                             \
+{                                                                         \
+    DEBUGOUTPUT("Error defined at %s, line %i : \n", __FILE__, __LINE__); \
+    DISPLAYLEVEL(1, "Error %i : ", error);                                \
+    DISPLAYLEVEL(1, __VA_ARGS__);                                         \
+    DISPLAYLEVEL(1, "\n");                                                \
+    exit(error);                                                          \
+}
+
+
+/* *************************************
+*  Benchmark Parameters
+***************************************/
+static U32 g_nbSeconds = NBSECONDS;
+static size_t g_blockSize = 0;
+int g_additionalParam = 0;
+
+void BMK_setNotificationLevel(unsigned level) { g_displayLevel=level; }
+
+void BMK_setAdditionalParam(int additionalParam) { g_additionalParam=additionalParam; }
+
+void BMK_SetNbSeconds(unsigned nbSeconds)
 {
-    U32   id;
-    char* origBuffer;
-    char* compressedBuffer;
-    int   origSize;
-    int   compressedSize;
-};
+    g_nbSeconds = nbSeconds;
+    DISPLAYLEVEL(3, "- test >= %u seconds per compression / decompression -\n", g_nbSeconds);
+}
+
+void BMK_SetBlockSize(size_t blockSize)
+{
+    g_blockSize = blockSize;
+}
+
+
+/* ********************************************************
+*  Bench functions
+**********************************************************/
+typedef struct {
+    const char* srcPtr;
+    size_t srcSize;
+    char*  cPtr;
+    size_t cRoom;
+    size_t cSize;
+    char*  resPtr;
+    size_t resSize;
+} blockParam_t;
 
 struct compressionParameters
 {
     int (*compressionFunction)(const char* src, char* dst, int srcSize, int dstSize, int cLevel);
-    int (*decompressionFunction)(const char* src, char* dst, int dstSize);
 };
 
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+#define MAX(a,b) ((a)>(b) ? (a) : (b))
 
-/**************************************
-*  MACRO
-***************************************/
-#define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
-
-
-/**************************************
-*  Benchmark Parameters
-***************************************/
-static int chunkSize = DEFAULT_CHUNKSIZE;
-static int nbIterations = NBLOOPS;
-static int BMK_pause = 0;
-
-void BMK_setBlocksize(int bsize) { chunkSize = bsize; }
-
-void BMK_setNbIterations(int nbLoops)
+static int BMK_benchMem(const void* srcBuffer, size_t srcSize,
+                        const char* displayName, int cLevel,
+                        const size_t* fileSizes, U32 nbFiles)
 {
-    nbIterations = nbLoops;
-    DISPLAY("- %i iterations -\n", nbIterations);
-}
+    size_t const blockSize = (g_blockSize>=32 ? g_blockSize : srcSize) + (!srcSize) /* avoid div by 0 */ ;
+    U32 const maxNbBlocks = (U32) ((srcSize + (blockSize-1)) / blockSize) + nbFiles;
+    blockParam_t* const blockTable = (blockParam_t*) malloc(maxNbBlocks * sizeof(blockParam_t));
+    size_t const maxCompressedSize = LZ4_compressBound((int)srcSize) + (maxNbBlocks * 1024);   /* add some room for safety */
+    void* const compressedBuffer = malloc(maxCompressedSize);
+    void* const resultBuffer = malloc(srcSize);
+    U32 nbBlocks;
+    UTIL_time_t ticksPerSecond;
+    struct compressionParameters compP;
+    int cfunctionId;
 
-void BMK_setPause(void) { BMK_pause = 1; }
+    /* checks */
+    if (!compressedBuffer || !resultBuffer || !blockTable)
+        EXM_THROW(31, "allocation error : not enough memory");
 
+    /* init */
+    if (strlen(displayName)>17) displayName += strlen(displayName)-17;   /* can only display 17 characters */
+    UTIL_initTimer(&ticksPerSecond);
 
-/*********************************************************
-*  Private functions
-**********************************************************/
-
-#if defined(BMK_LEGACY_TIMER)
-
-static int BMK_GetMilliStart(void)
-{
-  /* Based on Legacy ftime()
-     Rolls over every ~ 12.1 days (0x100000/24/60/60)
-     Use GetMilliSpan to correct for rollover */
-  struct timeb tb;
-  int nCount;
-  ftime( &tb );
-  nCount = (int) (tb.millitm + (tb.time & 0xfffff) * 1000);
-  return nCount;
-}
-
-#else
-
-static int BMK_GetMilliStart(void)
-{
-  /* Based on newer gettimeofday()
-     Use GetMilliSpan to correct for rollover */
-  struct timeval tv;
-  int nCount;
-  gettimeofday(&tv, NULL);
-  nCount = (int) (tv.tv_usec/1000 + (tv.tv_sec & 0xfffff) * 1000);
-  return nCount;
-}
-
+    /* Init */
+    if (cLevel < LZ4HC_CLEVEL_MIN) cfunctionId = 0; else cfunctionId = 1;
+    switch (cfunctionId)
+    {
+#ifdef COMPRESSOR0
+    case 0 : compP.compressionFunction = COMPRESSOR0; break;
 #endif
+#ifdef COMPRESSOR1
+    case 1 : compP.compressionFunction = COMPRESSOR1; break;
+#endif
+    default : compP.compressionFunction = DEFAULTCOMPRESSOR;
+    }
 
+    /* Init blockTable data */
+    {   const char* srcPtr = (const char*)srcBuffer;
+        char* cPtr = (char*)compressedBuffer;
+        char* resPtr = (char*)resultBuffer;
+        U32 fileNb;
+        for (nbBlocks=0, fileNb=0; fileNb<nbFiles; fileNb++) {
+            size_t remaining = fileSizes[fileNb];
+            U32 const nbBlocksforThisFile = (U32)((remaining + (blockSize-1)) / blockSize);
+            U32 const blockEnd = nbBlocks + nbBlocksforThisFile;
+            for ( ; nbBlocks<blockEnd; nbBlocks++) {
+                size_t const thisBlockSize = MIN(remaining, blockSize);
+                blockTable[nbBlocks].srcPtr = srcPtr;
+                blockTable[nbBlocks].cPtr = cPtr;
+                blockTable[nbBlocks].resPtr = resPtr;
+                blockTable[nbBlocks].srcSize = thisBlockSize;
+                blockTable[nbBlocks].cRoom = LZ4_compressBound((int)thisBlockSize);
+                srcPtr += thisBlockSize;
+                cPtr += blockTable[nbBlocks].cRoom;
+                resPtr += thisBlockSize;
+                remaining -= thisBlockSize;
+    }   }   }
 
-static int BMK_GetMilliSpan( int nTimeStart )
-{
-  int nSpan = BMK_GetMilliStart() - nTimeStart;
-  if ( nSpan < 0 )
-    nSpan += 0x100000 * 1000;
-  return nSpan;
+    /* warmimg up memory */
+    RDG_genBuffer(compressedBuffer, maxCompressedSize, 0.10, 0.50, 1);
+
+    /* Bench */
+    {   U64 fastestC = (U64)(-1LL), fastestD = (U64)(-1LL);
+        U64 const crcOrig = XXH64(srcBuffer, srcSize, 0);
+        UTIL_time_t coolTime;
+        U64 const maxTime = (g_nbSeconds * TIMELOOP_MICROSEC) + 100;
+        U64 totalCTime=0, totalDTime=0;
+        U32 cCompleted=0, dCompleted=0;
+#       define NB_MARKS 4
+        const char* const marks[NB_MARKS] = { " |", " /", " =",  "\\" };
+        U32 markNb = 0;
+        size_t cSize = 0;
+        double ratio = 0.;
+
+        UTIL_getTime(&coolTime);
+        DISPLAYLEVEL(2, "\r%79s\r", "");
+        while (!cCompleted || !dCompleted) {
+            UTIL_time_t clockStart;
+            U64 clockLoop = g_nbSeconds ? TIMELOOP_MICROSEC : 1;
+
+            /* overheat protection */
+            if (UTIL_clockSpanMicro(coolTime, ticksPerSecond) > ACTIVEPERIOD_MICROSEC) {
+                DISPLAYLEVEL(2, "\rcooling down ...    \r");
+                UTIL_sleep(COOLPERIOD_SEC);
+                UTIL_getTime(&coolTime);
+            }
+
+            /* Compression */
+            DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->\r", marks[markNb], displayName, (U32)srcSize);
+            if (!cCompleted) memset(compressedBuffer, 0xE5, maxCompressedSize);  /* warm up and erase result buffer */
+
+            UTIL_sleepMilli(1);  /* give processor time to other processes */
+            UTIL_waitForNextTick(ticksPerSecond);
+            UTIL_getTime(&clockStart);
+
+            if (!cCompleted) {   /* still some time to do compression tests */
+                U32 nbLoops = 0;
+                do {
+                    U32 blockNb;
+                    for (blockNb=0; blockNb<nbBlocks; blockNb++) {
+                        size_t const rSize = compP.compressionFunction(blockTable[blockNb].srcPtr, blockTable[blockNb].cPtr, (int)blockTable[blockNb].srcSize, (int)blockTable[blockNb].cRoom, cLevel);
+                        if (LZ4_isError(rSize)) EXM_THROW(1, "LZ4_compress() failed");
+                        blockTable[blockNb].cSize = rSize;
+                    }
+                    nbLoops++;
+                } while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < clockLoop);
+                {   U64 const clockSpan = UTIL_clockSpanMicro(clockStart, ticksPerSecond);
+                    if (clockSpan < fastestC*nbLoops) fastestC = clockSpan / nbLoops;
+                    totalCTime += clockSpan;
+                    cCompleted = totalCTime>maxTime;
+            }   }
+
+            cSize = 0;
+            { U32 blockNb; for (blockNb=0; blockNb<nbBlocks; blockNb++) cSize += blockTable[blockNb].cSize; }
+            cSize += !cSize;  /* avoid div by 0 */
+            ratio = (double)srcSize / (double)cSize;
+            markNb = (markNb+1) % NB_MARKS;
+            DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s\r",
+                    marks[markNb], displayName, (U32)srcSize, (U32)cSize, ratio,
+                    (double)srcSize / fastestC );
+
+            (void)fastestD; (void)crcOrig;   /*  unused when decompression disabled */
+#if 1
+            /* Decompression */
+            if (!dCompleted) memset(resultBuffer, 0xD6, srcSize);  /* warm result buffer */
+
+            UTIL_sleepMilli(1); /* give processor time to other processes */
+            UTIL_waitForNextTick(ticksPerSecond);
+            UTIL_getTime(&clockStart);
+
+            if (!dCompleted) {
+                U32 nbLoops = 0;
+                do {
+                    U32 blockNb;
+                    for (blockNb=0; blockNb<nbBlocks; blockNb++) {
+                        size_t const regenSize = LZ4_decompress_safe(blockTable[blockNb].cPtr, blockTable[blockNb].resPtr, (int)blockTable[blockNb].cSize, (int)blockTable[blockNb].srcSize);
+                        if (LZ4_isError(regenSize)) {
+                            DISPLAY("LZ4_decompress_safe() failed on block %u  \n", blockNb);
+                            clockLoop = 0;   /* force immediate test end */
+                            break;
+                        }
+
+                        blockTable[blockNb].resSize = regenSize;
+                    }
+                    nbLoops++;
+                } while (UTIL_clockSpanMicro(clockStart, ticksPerSecond) < DECOMP_MULT*clockLoop);
+                {   U64 const clockSpan = UTIL_clockSpanMicro(clockStart, ticksPerSecond);
+                    if (clockSpan < fastestD*nbLoops) fastestD = clockSpan / nbLoops;
+                    totalDTime += clockSpan;
+                    dCompleted = totalDTime>(DECOMP_MULT*maxTime);
+            }   }
+
+            markNb = (markNb+1) % NB_MARKS;
+            DISPLAYLEVEL(2, "%2s-%-17.17s :%10u ->%10u (%5.3f),%6.1f MB/s ,%6.1f MB/s\r",
+                    marks[markNb], displayName, (U32)srcSize, (U32)cSize, ratio,
+                    (double)srcSize / fastestC,
+                    (double)srcSize / fastestD );
+
+            /* CRC Checking */
+            {   U64 const crcCheck = XXH64(resultBuffer, srcSize, 0);
+                if (crcOrig!=crcCheck) {
+                    size_t u;
+                    DISPLAY("!!! WARNING !!! %14s : Invalid Checksum : %x != %x   \n", displayName, (unsigned)crcOrig, (unsigned)crcCheck);
+                    for (u=0; u<srcSize; u++) {
+                        if (((const BYTE*)srcBuffer)[u] != ((const BYTE*)resultBuffer)[u]) {
+                            U32 segNb, bNb, pos;
+                            size_t bacc = 0;
+                            DISPLAY("Decoding error at pos %u ", (U32)u);
+                            for (segNb = 0; segNb < nbBlocks; segNb++) {
+                                if (bacc + blockTable[segNb].srcSize > u) break;
+                                bacc += blockTable[segNb].srcSize;
+                            }
+                            pos = (U32)(u - bacc);
+                            bNb = pos / (128 KB);
+                            DISPLAY("(block %u, sub %u, pos %u) \n", segNb, bNb, pos);
+                            break;
+                        }
+                        if (u==srcSize-1) {  /* should never happen */
+                            DISPLAY("no difference detected\n");
+                    }   }
+                    break;
+            }   }   /* CRC Checking */
+#endif
+        }   /* for (testNb = 1; testNb <= (g_nbSeconds + !g_nbSeconds); testNb++) */
+
+        if (g_displayLevel == 1) {
+            double cSpeed = (double)srcSize / fastestC;
+            double dSpeed = (double)srcSize / fastestD;
+            if (g_additionalParam)
+                DISPLAY("-%-3i%11i (%5.3f) %6.2f MB/s %6.1f MB/s  %s (param=%d)\n", cLevel, (int)cSize, ratio, cSpeed, dSpeed, displayName, g_additionalParam);
+            else
+                DISPLAY("-%-3i%11i (%5.3f) %6.2f MB/s %6.1f MB/s  %s\n", cLevel, (int)cSize, ratio, cSpeed, dSpeed, displayName);
+        }
+        DISPLAYLEVEL(2, "%2i#\n", cLevel);
+    }   /* Bench */
+
+    /* clean up */
+    free(blockTable);
+    free(compressedBuffer);
+    free(resultBuffer);
+    return 0;
 }
 
 
@@ -200,10 +366,9 @@ static size_t BMK_findMaxMem(U64 requiredMem)
 
     requiredMem = (((requiredMem >> 26) + 1) << 26);
     requiredMem += 2*step;
-    if (requiredMem > MAX_MEM) requiredMem = MAX_MEM;
+    if (requiredMem > maxMemory) requiredMem = maxMemory;
 
-    while (!testmem)
-    {
+    while (!testmem) {
         if (requiredMem > step) requiredMem -= step;
         else requiredMem >>= 1;
         testmem = (BYTE*) malloc ((size_t)requiredMem);
@@ -218,220 +383,139 @@ static size_t BMK_findMaxMem(U64 requiredMem)
 }
 
 
-static U64 BMK_GetFileSize(const char* infilename)
+static void BMK_benchCLevel(void* srcBuffer, size_t benchedSize,
+                            const char* displayName, int cLevel, int cLevelLast,
+                            const size_t* fileSizes, unsigned nbFiles)
 {
-    int r;
-#if defined(_MSC_VER)
-    struct _stat64 statbuf;
-    r = _stat64(infilename, &statbuf);
-#else
-    struct stat statbuf;
-    r = stat(infilename, &statbuf);
-#endif
-    if (r || !S_ISREG(statbuf.st_mode)) return 0;   /* No good... */
-    return (U64)statbuf.st_size;
+    int l;
+
+    const char* pch = strrchr(displayName, '\\'); /* Windows */
+    if (!pch) pch = strrchr(displayName, '/'); /* Linux */
+    if (pch) displayName = pch+1;
+
+    SET_REALTIME_PRIORITY;
+
+    if (g_displayLevel == 1 && !g_additionalParam)
+        DISPLAY("bench %s %s: input %u bytes, %u seconds, %u KB blocks\n", LZ4_VERSION_STRING, LZ4_GIT_COMMIT_STRING, (U32)benchedSize, g_nbSeconds, (U32)(g_blockSize>>10));
+
+    if (cLevelLast < cLevel) cLevelLast = cLevel;
+
+    for (l=cLevel; l <= cLevelLast; l++) {
+        BMK_benchMem(srcBuffer, benchedSize,
+                     displayName, l,
+                     fileSizes, nbFiles);
+    }
 }
 
 
-/*********************************************************
-*  Public function
-**********************************************************/
-
-int BMK_benchFiles(const char** fileNamesTable, int nbFiles, int cLevel)
+/*! BMK_loadFiles() :
+    Loads `buffer` with content of files listed within `fileNamesTable`.
+    At most, fills `buffer` entirely */
+static void BMK_loadFiles(void* buffer, size_t bufferSize,
+                          size_t* fileSizes,
+                          const char** fileNamesTable, unsigned nbFiles)
 {
-  int fileIdx=0;
-  char* orig_buff;
-  struct compressionParameters compP;
-  int cfunctionId;
-
-  U64 totals = 0;
-  U64 totalz = 0;
-  double totalc = 0.;
-  double totald = 0.;
-
-
-  /* Init */
-  if (cLevel <= 3) cfunctionId = 0; else cfunctionId = 1;
-  switch (cfunctionId)
-  {
-#ifdef COMPRESSOR0
-  case 0 : compP.compressionFunction = COMPRESSOR0; break;
-#endif
-#ifdef COMPRESSOR1
-  case 1 : compP.compressionFunction = COMPRESSOR1; break;
-#endif
-  default : compP.compressionFunction = DEFAULTCOMPRESSOR;
-  }
-  compP.decompressionFunction = LZ4_decompress_fast;
-
-  /* Loop for each file */
-  while (fileIdx<nbFiles)
-  {
-      FILE*  inFile;
-      const char*  inFileName;
-      U64    inFileSize;
-      size_t benchedSize;
-      int nbChunks;
-      int maxCompressedChunkSize;
-      size_t readSize;
-      char* compressedBuffer; int compressedBuffSize;
-      struct chunkParameters* chunkP;
-      U32 crcOrig;
-
-      /* Check file existence */
-      inFileName = fileNamesTable[fileIdx++];
-      inFile = fopen( inFileName, "rb" );
-      if (inFile==NULL) { DISPLAY( "Pb opening %s\n", inFileName); return 11; }
-
-      /* Memory allocation & restrictions */
-      inFileSize = BMK_GetFileSize(inFileName);
-      if (inFileSize==0) { DISPLAY( "file is empty\n"); fclose(inFile); return 11; }
-      benchedSize = (size_t) BMK_findMaxMem(inFileSize * 2) / 2;
-      if (benchedSize==0) { DISPLAY( "not enough memory\n"); fclose(inFile); return 11; }
-      if ((U64)benchedSize > inFileSize) benchedSize = (size_t)inFileSize;
-      if (benchedSize < inFileSize)
-      {
-          DISPLAY("Not enough memory for '%s' full size; testing %i MB only...\n", inFileName, (int)(benchedSize>>20));
-      }
-
-      /* Alloc */
-      chunkP = (struct chunkParameters*) malloc(((benchedSize / (size_t)chunkSize)+1) * sizeof(struct chunkParameters));
-      orig_buff = (char*)malloc((size_t)benchedSize);
-      nbChunks = (int) ((int)benchedSize / chunkSize) + 1;
-      maxCompressedChunkSize = LZ4_compressBound(chunkSize);
-      compressedBuffSize = nbChunks * maxCompressedChunkSize;
-      compressedBuffer = (char*)malloc((size_t)compressedBuffSize);
-
-      if (!orig_buff || !compressedBuffer)
-      {
-        DISPLAY("\nError: not enough memory!\n");
-        free(orig_buff);
-        free(compressedBuffer);
-        free(chunkP);
-        fclose(inFile);
-        return 12;
-      }
-
-      /* Init chunks data */
-      {
-          int i;
-          size_t remaining = benchedSize;
-          char* in = orig_buff;
-          char* out = compressedBuffer;
-          for (i=0; i<nbChunks; i++)
-          {
-              chunkP[i].id = i;
-              chunkP[i].origBuffer = in; in += chunkSize;
-              if ((int)remaining > chunkSize) { chunkP[i].origSize = chunkSize; remaining -= chunkSize; } else { chunkP[i].origSize = (int)remaining; remaining = 0; }
-              chunkP[i].compressedBuffer = out; out += maxCompressedChunkSize;
-              chunkP[i].compressedSize = 0;
-          }
-      }
-
-      /* Fill input buffer */
-      DISPLAY("Loading %s...       \r", inFileName);
-      readSize = fread(orig_buff, 1, benchedSize, inFile);
-      fclose(inFile);
-
-      if (readSize != benchedSize)
-      {
-        DISPLAY("\nError: problem reading file '%s' !!    \n", inFileName);
-        free(orig_buff);
-        free(compressedBuffer);
-        free(chunkP);
-        return 13;
-      }
-
-      /* Calculating input Checksum */
-      crcOrig = XXH32(orig_buff, (unsigned int)benchedSize,0);
-
-
-      /* Bench */
-      {
-        int loopNb, chunkNb;
-        size_t cSize=0;
-        double fastestC = 100000000., fastestD = 100000000.;
-        double ratio=0.;
-        U32 crcCheck=0;
-
-        DISPLAY("\r%79s\r", "");
-        for (loopNb = 1; loopNb <= nbIterations; loopNb++)
-        {
-          int nbLoops;
-          int milliTime;
-
-          /* Compression */
-          DISPLAY("%1i-%-14.14s : %9i ->\r", loopNb, inFileName, (int)benchedSize);
-          { size_t i; for (i=0; i<benchedSize; i++) compressedBuffer[i]=(char)i; }     /* warmimg up memory */
-
-          nbLoops = 0;
-          milliTime = BMK_GetMilliStart();
-          while(BMK_GetMilliStart() == milliTime);
-          milliTime = BMK_GetMilliStart();
-          while(BMK_GetMilliSpan(milliTime) < TIMELOOP)
-          {
-            for (chunkNb=0; chunkNb<nbChunks; chunkNb++)
-                chunkP[chunkNb].compressedSize = compP.compressionFunction(chunkP[chunkNb].origBuffer, chunkP[chunkNb].compressedBuffer, chunkP[chunkNb].origSize, maxCompressedChunkSize, cLevel);
-            nbLoops++;
-          }
-          milliTime = BMK_GetMilliSpan(milliTime);
-
-          nbLoops += !nbLoops;   /* avoid division by zero */
-          if ((double)milliTime < fastestC*nbLoops) fastestC = (double)milliTime/nbLoops;
-          cSize=0; for (chunkNb=0; chunkNb<nbChunks; chunkNb++) cSize += chunkP[chunkNb].compressedSize;
-          ratio = (double)cSize/(double)benchedSize*100.;
-
-          DISPLAY("%1i-%-14.14s : %9i -> %9i (%5.2f%%),%7.1f MB/s\r", loopNb, inFileName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / fastestC / 1000.);
-
-          /* Decompression */
-          { size_t i; for (i=0; i<benchedSize; i++) orig_buff[i]=0; }     /* zeroing area, for CRC checking */
-
-          nbLoops = 0;
-          milliTime = BMK_GetMilliStart();
-          while(BMK_GetMilliStart() == milliTime);
-          milliTime = BMK_GetMilliStart();
-          while(BMK_GetMilliSpan(milliTime) < TIMELOOP)
-          {
-            for (chunkNb=0; chunkNb<nbChunks; chunkNb++)
-                chunkP[chunkNb].compressedSize = LZ4_decompress_fast(chunkP[chunkNb].compressedBuffer, chunkP[chunkNb].origBuffer, chunkP[chunkNb].origSize);
-            nbLoops++;
-          }
-          milliTime = BMK_GetMilliSpan(milliTime);
-
-          nbLoops += !nbLoops;   /* avoid division by zero */
-          if ((double)milliTime < fastestD*nbLoops) fastestD = (double)milliTime/nbLoops;
-          DISPLAY("%1i-%-14.14s : %9i -> %9i (%5.2f%%),%7.1f MB/s ,%7.1f MB/s \r", loopNb, inFileName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / fastestC / 1000., (double)benchedSize / fastestD / 1000.);
-
-          /* CRC Checking */
-          crcCheck = XXH32(orig_buff, (unsigned int)benchedSize,0);
-          if (crcOrig!=crcCheck) { DISPLAY("\n!!! WARNING !!! %14s : Invalid Checksum : %x != %x\n", inFileName, (unsigned)crcOrig, (unsigned)crcCheck); break; }
+    size_t pos = 0, totalSize = 0;
+    unsigned n;
+    for (n=0; n<nbFiles; n++) {
+        FILE* f;
+        U64 fileSize = UTIL_getFileSize(fileNamesTable[n]);
+        if (UTIL_isDirectory(fileNamesTable[n])) {
+            DISPLAYLEVEL(2, "Ignoring %s directory...       \n", fileNamesTable[n]);
+            fileSizes[n] = 0;
+            continue;
         }
+        f = fopen(fileNamesTable[n], "rb");
+        if (f==NULL) EXM_THROW(10, "impossible to open file %s", fileNamesTable[n]);
+        DISPLAYUPDATE(2, "Loading %s...       \r", fileNamesTable[n]);
+        if (fileSize > bufferSize-pos) fileSize = bufferSize-pos, nbFiles=n;   /* buffer too small - stop after this file */
+        { size_t const readSize = fread(((char*)buffer)+pos, 1, (size_t)fileSize, f);
+          if (readSize != (size_t)fileSize) EXM_THROW(11, "could not read %s", fileNamesTable[n]);
+          pos += readSize; }
+        fileSizes[n] = (size_t)fileSize;
+        totalSize += (size_t)fileSize;
+        fclose(f);
+    }
 
-        if (crcOrig==crcCheck)
-        {
-            if (ratio<100.)
-                DISPLAY("%-16.16s : %9i -> %9i (%5.2f%%),%7.1f MB/s ,%7.1f MB/s \n", inFileName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / fastestC / 1000., (double)benchedSize / fastestD / 1000.);
-            else
-                DISPLAY("%-16.16s : %9i -> %9i (%5.1f%%),%7.1f MB/s ,%7.1f MB/s  \n", inFileName, (int)benchedSize, (int)cSize, ratio, (double)benchedSize / fastestC / 1000., (double)benchedSize / fastestD / 1000.);
-        }
-        totals += benchedSize;
-        totalz += cSize;
-        totalc += fastestC;
-        totald += fastestD;
-      }
+    if (totalSize == 0) EXM_THROW(12, "no data to bench");
+}
 
-      free(orig_buff);
-      free(compressedBuffer);
-      free(chunkP);
-  }
+static void BMK_benchFileTable(const char** fileNamesTable, unsigned nbFiles,
+                               int cLevel, int cLevelLast)
+{
+    void* srcBuffer;
+    size_t benchedSize;
+    size_t* fileSizes = (size_t*)malloc(nbFiles * sizeof(size_t));
+    U64 const totalSizeToLoad = UTIL_getTotalFileSize(fileNamesTable, nbFiles);
+    char mfName[20] = {0};
 
-  if (nbFiles > 1)
-        DISPLAY("%-16.16s :%10llu ->%10llu (%5.2f%%), %6.1f MB/s , %6.1f MB/s\n", "  TOTAL", (long long unsigned int)totals, (long long unsigned int)totalz, (double)totalz/(double)totals*100., (double)totals/totalc/1000., (double)totals/totald/1000.);
+    if (!fileSizes) EXM_THROW(12, "not enough memory for fileSizes");
 
-  if (BMK_pause) { DISPLAY("\npress enter...\n"); (void)getchar(); }
+    /* Memory allocation & restrictions */
+    benchedSize = BMK_findMaxMem(totalSizeToLoad * 3) / 3;
+    if (benchedSize==0) EXM_THROW(12, "not enough memory");
+    if ((U64)benchedSize > totalSizeToLoad) benchedSize = (size_t)totalSizeToLoad;
+    if (benchedSize > LZ4_MAX_INPUT_SIZE) {
+        benchedSize = LZ4_MAX_INPUT_SIZE; 
+        DISPLAY("File(s) bigger than LZ4's max input size; testing %u MB only...\n", (U32)(benchedSize >> 20));
+    } else { 
+        if (benchedSize < totalSizeToLoad)
+            DISPLAY("Not enough memory; testing %u MB only...\n", (U32)(benchedSize >> 20));
+    }
+    srcBuffer = malloc(benchedSize + !benchedSize);   /* avoid alloc of zero */
+    if (!srcBuffer) EXM_THROW(12, "not enough memory");
 
-  return 0;
+    /* Load input buffer */
+    BMK_loadFiles(srcBuffer, benchedSize, fileSizes, fileNamesTable, nbFiles);
+
+    /* Bench */
+    snprintf (mfName, sizeof(mfName), " %u files", nbFiles);
+    {   const char* displayName = (nbFiles > 1) ? mfName : fileNamesTable[0];
+        BMK_benchCLevel(srcBuffer, benchedSize,
+                        displayName, cLevel, cLevelLast,
+                        fileSizes, nbFiles);
+    }
+
+    /* clean up */
+    free(srcBuffer);
+    free(fileSizes);
 }
 
 
+static void BMK_syntheticTest(int cLevel, int cLevelLast, double compressibility)
+{
+    char name[20] = {0};
+    size_t benchedSize = 10000000;
+    void* const srcBuffer = malloc(benchedSize);
 
+    /* Memory allocation */
+    if (!srcBuffer) EXM_THROW(21, "not enough memory");
+
+    /* Fill input buffer */
+    RDG_genBuffer(srcBuffer, benchedSize, compressibility, 0.0, 0);
+
+    /* Bench */
+    snprintf (name, sizeof(name), "Synthetic %2u%%", (unsigned)(compressibility*100));
+    BMK_benchCLevel(srcBuffer, benchedSize, name, cLevel, cLevelLast, &benchedSize, 1);
+
+    /* clean up */
+    free(srcBuffer);
+}
+
+
+int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
+                   int cLevel, int cLevelLast)
+{
+    double const compressibility = (double)g_compressibilityDefault / 100;
+
+    if (cLevel > LZ4HC_CLEVEL_MAX) cLevel = LZ4HC_CLEVEL_MAX;
+    if (cLevelLast > LZ4HC_CLEVEL_MAX) cLevelLast = LZ4HC_CLEVEL_MAX;
+    if (cLevelLast < cLevel) cLevelLast = cLevel;
+    if (cLevelLast > cLevel) DISPLAYLEVEL(2, "Benchmarking levels from %d to %d\n", cLevel, cLevelLast);
+
+    if (nbFiles == 0)
+        BMK_syntheticTest(cLevel, cLevelLast, compressibility);
+    else
+        BMK_benchFileTable(fileNamesTable, nbFiles, cLevel, cLevelLast);
+    return 0;
+}

src/lz4/programs/bench.h

@@ -1,6 +1,6 @@
 /*
     bench.h - Demo program to benchmark open-source compression algorithm
-    Copyright (C) Yann Collet 2012-2015
+    Copyright (C) Yann Collet 2012-2016
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -17,17 +17,21 @@
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
     You can contact the author at :
-    - LZ4 source repository : https://github.com/Cyan4973/lz4
+    - LZ4 source repository : https://github.com/lz4/lz4
     - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
 */
-#pragma once
+#ifndef BENCH_H_125623623633
+#define BENCH_H_125623623633
 
+#include <stddef.h>
 
-/* Main function */
-int BMK_benchFiles(const char** fileNamesTable, int nbFiles, int cLevel);
+int BMK_benchFiles(const char** fileNamesTable, unsigned nbFiles,
+                   int cLevel, int cLevelLast);
 
 /* Set Parameters */
-void BMK_setBlocksize(int bsize);
-void BMK_setNbIterations(int nbLoops);
-void BMK_setPause(void);
+void BMK_SetNbSeconds(unsigned nbLoops);
+void BMK_SetBlockSize(size_t blockSize);
+void BMK_setAdditionalParam(int additionalParam);
+void BMK_setNotificationLevel(unsigned level);
 
+#endif   /* BENCH_H_125623623633 */