Merge pull request #109 from Cyan4973/dev

Dev
2016-01-12 18:51:06 +01:00 · 2016-01-12 18:51:06 +01:00 · 0022b34366
commit 0022b34366
parent 8b8f3c16b2 62635c42fc
11 changed files with 820 additions and 8 deletions
--- a/.gitignore
+++ b/.gitignore
@ -37,4 +37,10 @@ ipch/
 *.opendb
 *.opensdf
 *.sdf
-*.cachefile
+*.cachefile
+
+# IDEA solution files
+*.idea
+
+# Other files
+.directory
--- a/.travis.yml
+++ b/.travis.yml
@ -1,7 +1,9 @@
 language: c
-compiler: gcc
-script: make $ZSTD_TRAVIS_CI_ENV
+
 before_install:
+  - "wget https://launchpad.net/ubuntu/+source/cmake/2.8.8-2ubuntu1/+build/3441442/+files/cmake_2.8.8-2ubuntu1_amd64.deb"
+  - "wget https://launchpad.net/ubuntu/+archive/primary/+files/cmake-data_2.8.8-2ubuntu1_all.deb"
+  - "sudo apt-get remove cmake-data cmake"
  - sudo apt-get update  -qq
  - sudo apt-get install -qq gcc-arm-linux-gnueabi
  - sudo apt-get install -qq clang
@ -9,8 +11,12 @@ before_install:
  - sudo apt-get install -qq gcc-multilib
  - sudo apt-get install -qq valgrind

+install:
+    - "sudo dpkg --install cmake-data_2.8.8-2ubuntu1_all.deb cmake_2.8.8-2ubuntu1_amd64.deb" 
+
 env:
  - ZSTD_TRAVIS_CI_ENV=travis-install
+  - ZSTD_TRAVIS_CI_ENV=cmaketest
  - ZSTD_TRAVIS_CI_ENV=clangtest  
  - ZSTD_TRAVIS_CI_ENV=gpptest  
  - ZSTD_TRAVIS_CI_ENV=armtest  
@ -21,6 +27,11 @@ env:
  - ZSTD_TRAVIS_CI_ENV=asan
  - ZSTD_TRAVIS_CI_ENV=asan32
  - ZSTD_TRAVIS_CI_ENV="-C programs valgrindTest"  
+  
+compiler: gcc
+
+script: 
+  - make $ZSTD_TRAVIS_CI_ENV

 matrix:
-  fast_finish: true
+  fast_finish: true
--- a/3
+++ b/3
@ -79,6 +79,9 @@ travis-install:
 test:
 	$(MAKE) -C $(PRGDIR) $@

+cmaketest:
+	cd contrib/cmake ; cmake . ; $(MAKE)
+
 clangtest: clean
 	clang -v
 	$(MAKE) all CC=clang MOREFLAGS="-Werror -Wconversion -Wno-sign-conversion"
--- a/1
+++ b/1
@ -1,5 +1,6 @@
 v0.4.6
 fix : fast compression mode on Windows
+New : cmake configuration file, thanks to Artyom Dymchenko
 Improved : high compression mode on repetitive data
 New : block-level API
 New : ZSTD_duplicateCCtx()
--- a/contrib/cmake/CMakeLists.txt
+++ b/contrib/cmake/CMakeLists.txt
@ -0,0 +1,63 @@
+# ################################################################
+# zstd - Makefile
+# Copyright (C) Yann Collet 2014-2015
+# 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 :
+#  - zstd source repository : https://github.com/Cyan4973/zstd
+#  - Public forum : https://groups.google.com/forum/#!forum/lz4c
+# ################################################################
+
+PROJECT(zstd)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.8)
+
+OPTION(ZSTD_LEGACY_SUPPORT "LEGACY SUPPORT" OFF)
+
+IF (ZSTD_LEGACY_SUPPORT)
+    MESSAGE(STATUS "ZSTD_LEGACY_SUPPORT defined!")
+    ADD_DEFINITIONS(-DZSTD_LEGACY_SUPPORT=1)
+ELSE (ZSTD_LEGACY_SUPPORT)
+    MESSAGE(STATUS "ZSTD_LEGACY_SUPPORT not defined!")
+    ADD_DEFINITIONS(-DZSTD_LEGACY_SUPPORT=0)
+ENDIF (ZSTD_LEGACY_SUPPORT)
+
+INCLUDE(CMakeModules/CompareVersion.cmake)
+COMPARE_VERSION_STRINGS("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}" "2.8.8" CMP_RESULT)
+
+IF ((CMP_RESULT LESS 0) OR (CMP_RESULT EQUAL 0))
+    SET(USE_DEPRECATED_CODE_STYLE TRUE)
+ELSE ()
+    SET(USE_DEPRECATED_CODE_STYLE FALSE)
+ENDIF ((CMP_RESULT LESS 0) OR (CMP_RESULT EQUAL 0))
+
+ADD_SUBDIRECTORY(lib)
+ADD_SUBDIRECTORY(programs)
+
+#-----------------------------------------------------------------------------
+# Add extra compilation flags
+#-----------------------------------------------------------------------------
+INCLUDE(CMakeModules/AddExtraCompilationFlags.cmake)
+ADD_EXTRA_COMPILATION_FLAGS()
--- a/contrib/cmake/CMakeModules/AddExtraCompilationFlags.cmake
+++ b/contrib/cmake/CMakeModules/AddExtraCompilationFlags.cmake
@ -0,0 +1,331 @@
+MACRO(ADD_EXTRA_COMPILATION_FLAGS)
+    include(CheckCXXCompilerFlag)
+    include(CheckCCompilerFlag)
+    if (CMAKE_COMPILER_IS_GNUCXX OR MINGW) #Not only UNIX but also WIN32 for MinGW
+
+        set(POSITION_INDEPENDENT_CODE_FLAG "-fPIC")
+        CHECK_C_COMPILER_FLAG(${POSITION_INDEPENDENT_CODE_FLAG} POSITION_INDEPENDENT_CODE_FLAG_ALLOWED)
+        if (POSITION_INDEPENDENT_CODE_FLAG_ALLOWED)
+            MESSAGE("Compiler flag ${POSITION_INDEPENDENT_CODE_FLAG} allowed")
+            set(ACTIVATE_POSITION_INDEPENDENT_CODE_FLAG "ON" CACHE BOOL "activate -fPIC flag")
+        else ()
+            MESSAGE("Compiler flag ${POSITION_INDEPENDENT_CODE_FLAG} not allowed")
+        endif (POSITION_INDEPENDENT_CODE_FLAG_ALLOWED)
+
+        set(WARNING_UNDEF "-Wundef")
+        CHECK_C_COMPILER_FLAG(${WARNING_UNDEF} WARNING_UNDEF_ALLOWED)
+        if (WARNING_UNDEF_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_UNDEF} allowed")
+            set(ACTIVATE_WARNING_UNDEF "ON" CACHE BOOL "activate -Wundef flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_UNDEF} not allowed")
+        endif (WARNING_UNDEF_ALLOWED)
+
+        set(WARNING_SHADOW "-Wshadow")
+        CHECK_C_COMPILER_FLAG(${WARNING_SHADOW} WARNING_SHADOW_ALLOWED)
+        if (WARNING_SHADOW_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_SHADOW} allowed")
+            set(ACTIVATE_WARNING_SHADOW "ON" CACHE BOOL "activate -Wshadow flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_SHADOW} not allowed")
+        endif (WARNING_SHADOW_ALLOWED)
+
+        set(WARNING_CAST_ALIGN "-Wcast-align")
+        CHECK_C_COMPILER_FLAG(${WARNING_CAST_ALIGN} WARNING_CAST_ALIGN_ALLOWED)
+        if (WARNING_CAST_ALIGN_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_CAST_ALIGN} allowed")
+            set(ACTIVATE_WARNING_CAST_ALIGN "ON" CACHE BOOL "activate -Wcast-align flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_CAST_ALIGN} not allowed")
+        endif (WARNING_CAST_ALIGN_ALLOWED)
+
+        set(WARNING_CAST_QUAL "-Wcast-qual")
+        CHECK_C_COMPILER_FLAG(${WARNING_CAST_QUAL} WARNING_CAST_QUAL_ALLOWED)
+        if (WARNING_CAST_QUAL_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_CAST_QUAL} allowed")
+            set(ACTIVATE_WARNING_CAST_QUAL "ON" CACHE BOOL "activate -Wcast-qual flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_CAST_QUAL} not allowed")
+        endif (WARNING_CAST_QUAL_ALLOWED)
+
+        set(WARNING_STRICT_PROTOTYPES "-Wstrict-prototypes")
+        CHECK_C_COMPILER_FLAG(${WARNING_STRICT_PROTOTYPES} WARNING_STRICT_PROTOTYPES_ALLOWED)
+        if (WARNING_STRICT_PROTOTYPES_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_STRICT_PROTOTYPES} allowed")
+            set(ACTIVATE_WARNING_STRICT_PROTOTYPES "ON" CACHE BOOL "activate -Wstrict-prototypes flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_STRICT_PROTOTYPES} not allowed")
+        endif (WARNING_STRICT_PROTOTYPES_ALLOWED)
+
+        set(WARNING_ALL "-Wall")
+        CHECK_C_COMPILER_FLAG(${WARNING_ALL} WARNING_ALL_ALLOWED)
+        if (WARNING_ALL_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_ALL} allowed")
+            set(ACTIVATE_WARNING_ALL "ON" CACHE BOOL "activate -Wall flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_ALL} not allowed")
+        endif (WARNING_ALL_ALLOWED)
+
+        set(WARNING_EXTRA "-Wextra")
+        CHECK_C_COMPILER_FLAG(${WARNING_EXTRA} WARNING_EXTRA_ALLOWED)
+        if (WARNING_EXTRA_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_EXTRA} allowed")
+            set(ACTIVATE_WARNING_EXTRA "ON" CACHE BOOL "activate -Wextra flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_EXTRA} not allowed")
+        endif (WARNING_EXTRA_ALLOWED)
+
+        set(WARNING_FLOAT_EQUAL "-Wfloat-equal")
+        CHECK_C_COMPILER_FLAG(${WARNING_FLOAT_EQUAL} WARNING_FLOAT_EQUAL_ALLOWED)
+        if (WARNING_FLOAT_EQUAL_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_FLOAT_EQUAL} allowed")
+            set(ACTIVATE_WARNING_FLOAT_EQUAL "OFF" CACHE BOOL "activate -Wfloat-equal flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_FLOAT_EQUAL} not allowed")
+        endif (WARNING_FLOAT_EQUAL_ALLOWED)
+
+        set(WARNING_SIGN_CONVERSION "-Wsign-conversion")
+        CHECK_C_COMPILER_FLAG(${WARNING_SIGN_CONVERSION} WARNING_SIGN_CONVERSION_ALLOWED)
+        if (WARNING_SIGN_CONVERSION_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_SIGN_CONVERSION} allowed")
+            set(ACTIVATE_WARNING_SIGN_CONVERSION "OFF" CACHE BOOL "activate -Wsign-conversion flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_SIGN_CONVERSION} not allowed")
+        endif (WARNING_SIGN_CONVERSION_ALLOWED)
+
+        if (ACTIVATE_POSITION_INDEPENDENT_CODE_FLAG)
+            list(APPEND CMAKE_C_FLAGS ${POSITION_INDEPENDENT_CODE_FLAG})
+        else ()
+            string(REPLACE ${POSITION_INDEPENDENT_CODE_FLAG} "" CMAKE_C_FLAGS "${POSITION_INDEPENDENT_CODE_FLAG}")
+        endif (ACTIVATE_POSITION_INDEPENDENT_CODE_FLAG)
+
+        if (ACTIVATE_WARNING_UNDEF)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_UNDEF})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_UNDEF})
+        else ()
+            string(REPLACE ${WARNING_UNDEF} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_UNDEF} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_UNDEF)
+
+        if (ACTIVATE_WARNING_SHADOW)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_SHADOW})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_SHADOW})
+        else ()
+            string(REPLACE ${WARNING_SHADOW} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_SHADOW} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_SHADOW)
+
+        if (ACTIVATE_WARNING_CAST_QUAL)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_CAST_QUAL})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_CAST_QUAL})
+        else ()
+            string(REPLACE ${WARNING_CAST_QUAL} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_CAST_QUAL} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_CAST_QUAL)
+
+        if (ACTIVATE_WARNING_CAST_ALIGN)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_CAST_ALIGN})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_CAST_ALIGN})
+        else ()
+            string(REPLACE ${WARNING_CAST_ALIGN} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_CAST_ALIGN} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_CAST_ALIGN)
+
+        if (ACTIVATE_WARNING_STRICT_PROTOTYPES)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_STRICT_PROTOTYPES})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_STRICT_PROTOTYPES})
+        else ()
+            string(REPLACE ${WARNING_STRICT_PROTOTYPES} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_STRICT_PROTOTYPES} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_STRICT_PROTOTYPES)
+
+        if (ACTIVATE_WARNING_ALL)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_ALL})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_ALL})
+        else ()
+            string(REPLACE ${WARNING_ALL} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_ALL} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_ALL)
+
+        if (ACTIVATE_WARNING_EXTRA)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_EXTRA})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_EXTRA})
+        else ()
+            string(REPLACE ${WARNING_EXTRA} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_EXTRA} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_EXTRA)
+
+        if (ACTIVATE_WARNING_FLOAT_EQUAL)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_FLOAT_EQUAL})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_FLOAT_EQUAL})
+        else ()
+            string(REPLACE ${WARNING_FLOAT_EQUAL} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_FLOAT_EQUAL} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_FLOAT_EQUAL)
+
+        if (ACTIVATE_WARNING_SIGN_CONVERSION)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_SIGN_CONVERSION})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_SIGN_CONVERSION})
+        else ()
+            string(REPLACE ${WARNING_SIGN_CONVERSION} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_SIGN_CONVERSION} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_SIGN_CONVERSION)
+
+        #Set c++11 by default
+        list(APPEND CMAKE_CXX_FLAGS "-std=c++11")
+
+        #Set c99 by default
+        list(APPEND CMAKE_C_FLAGS "-std=c99")
+
+    elseif (MSVC)
+        # Add specific compilation flags for Windows Visual
+
+        set(WARNING_ALL "/Wall")
+        CHECK_C_COMPILER_FLAG(${WARNING_ALL} WARNING_ALL_ALLOWED)
+        if (WARNING_ALL_ALLOWED)
+            MESSAGE("Compiler flag ${WARNING_ALL} allowed")
+            set(ACTIVATE_WARNING_ALL "OFF" CACHE BOOL "activate /Wall flag")
+        else ()
+            MESSAGE("Compiler flag ${WARNING_ALL} not allowed")
+        endif (WARNING_ALL_ALLOWED)
+        	
+        set(RTC_FLAG "/RTC1")
+        CHECK_C_COMPILER_FLAG(${RTC_FLAG} RTC_FLAG_ALLOWED)
+        if (RTC_FLAG_ALLOWED)
+            MESSAGE("Compiler flag ${RTC_FLAG} allowed")
+            set(ACTIVATE_RTC_FLAG "ON" CACHE BOOL "activate /RTC1 flag")
+        else ()
+            MESSAGE("Compiler flag ${RTC_FLAG} not allowed")
+        endif (RTC_FLAG_ALLOWED)
+        	
+        set(ZC_FLAG "/Zc:forScope")
+        CHECK_C_COMPILER_FLAG(${ZC_FLAG} ZC_FLAG_ALLOWED)
+        if (ZC_FLAG_ALLOWED)
+            MESSAGE("Compiler flag ${ZC_FLAG} allowed")
+            set(ACTIVATE_ZC_FLAG "ON" CACHE BOOL "activate /Zc:forScope flag")
+        else ()
+            MESSAGE("Compiler flag ${ZC_FLAG} not allowed")
+        endif (ZC_FLAG_ALLOWED)
+        	
+        set(GD_FLAG "/Gd")
+        CHECK_C_COMPILER_FLAG(${GD_FLAG} GD_FLAG_ALLOWED)
+        if (GD_FLAG_ALLOWED)
+            MESSAGE("Compiler flag ${GD_FLAG} allowed")
+            set(ACTIVATE_GD_FLAG "ON" CACHE BOOL "activate /Gd flag")
+        else ()
+            MESSAGE("Compiler flag ${GD_FLAG} not allowed")
+        endif (GD_FLAG_ALLOWED)
+        	
+        set(ANALYZE_FLAG "/analyze:stacksize25000")
+        CHECK_C_COMPILER_FLAG(${ANALYZE_FLAG} ANALYZE_FLAG_ALLOWED)
+        if (ANALYZE_FLAG_ALLOWED)
+            MESSAGE("Compiler flag ${ANALYZE_FLAG} allowed")
+            set(ACTIVATE_ANALYZE_FLAG "ON" CACHE BOOL "activate /ANALYZE flag")
+        else ()
+            MESSAGE("Compiler flag ${ANALYZE_FLAG} not allowed")
+        endif (ANALYZE_FLAG_ALLOWED)
+
+        if (ACTIVATE_WARNING_ALL)
+            list(APPEND CMAKE_CXX_FLAGS ${WARNING_ALL})
+            list(APPEND CMAKE_C_FLAGS ${WARNING_ALL})
+        else ()
+            string(REPLACE ${WARNING_ALL} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${WARNING_ALL} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_WARNING_ALL)
+        	
+        # Only for DEBUG version
+        if (ACTIVATE_RTC_FLAG)
+            list(APPEND CMAKE_CXX_FLAGS_DEBUG ${RTC_FLAG})
+            list(APPEND CMAKE_C_FLAGS_DEBUG ${RTC_FLAG})
+        else ()
+            string(REPLACE ${RTC_FLAG} "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+            string(REPLACE ${RTC_FLAG} "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+        endif (ACTIVATE_RTC_FLAG)
+        	
+        if (ACTIVATE_ZC_FLAG)
+            list(APPEND CMAKE_CXX_FLAGS ${ZC_FLAG})
+            list(APPEND CMAKE_C_FLAGS ${ZC_FLAG})
+        else ()
+            string(REPLACE ${ZC_FLAG} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${ZC_FLAG} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_ZC_FLAG)
+        	
+        if (ACTIVATE_GD_FLAG)
+            list(APPEND CMAKE_CXX_FLAGS ${GD_FLAG})
+            list(APPEND CMAKE_C_FLAGS ${GD_FLAG})
+        else ()
+            string(REPLACE ${GD_FLAG} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${GD_FLAG} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_GD_FLAG)
+        	
+        if (ACTIVATE_ANALYZE_FLAG)
+            list(APPEND CMAKE_CXX_FLAGS ${ANALYZE_FLAG})
+            list(APPEND CMAKE_C_FLAGS ${ANALYZE_FLAG})
+        else ()
+            string(REPLACE ${ANALYZE_FLAG} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${ANALYZE_FLAG} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_ANALYZE_FLAG)
+        	
+        if (MSVC80 OR MSVC90 OR MSVC10 OR MSVC11)
+            # To avoid compiler warning (level 4) C4571, compile with /EHa if you still want
+            # your catch(...) blocks to catch structured exceptions.
+            list(APPEND CMAKE_CXX_FLAGS "/EHa")
+        endif (MSVC80 OR MSVC90 OR MSVC10 OR MSVC11)
+
+        set(MULTITHREADED_COMPILATION "/MP")
+        MESSAGE("Compiler flag ${MULTITHREADED_COMPILATION} allowed")
+        set(ACTIVATE_MULTITHREADED_COMPILATION "ON" CACHE BOOL "activate /MP flag")
+
+        if (ACTIVATE_MULTITHREADED_COMPILATION)
+            list(APPEND CMAKE_CXX_FLAGS ${MULTITHREADED_COMPILATION})
+            list(APPEND CMAKE_C_FLAGS ${MULTITHREADED_COMPILATION})
+        else ()
+            string(REPLACE ${MULTITHREADED_COMPILATION} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+            string(REPLACE ${MULTITHREADED_COMPILATION} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
+        endif (ACTIVATE_MULTITHREADED_COMPILATION)
+
+        #For exceptions
+        list(APPEND CMAKE_CXX_FLAGS "/EHsc")
+        list(APPEND CMAKE_C_FLAGS "/EHsc")
+        
+        # UNICODE SUPPORT
+        list(APPEND CMAKE_CXX_FLAGS "/D_UNICODE /DUNICODE")
+        list(APPEND CMAKE_C_FLAGS "/D_UNICODE /DUNICODE")
+    endif ()
+
+    # Remove duplicates compilation flags
+	FOREACH (flag_var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+                CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+		        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+		                CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+	    separate_arguments(${flag_var})
+	    list(REMOVE_DUPLICATES ${flag_var})
+	    string(REPLACE ";" " " ${flag_var} "${${flag_var}}")
+	    set(${flag_var} "${${flag_var}}" CACHE STRING "common build flags" FORCE)
+    ENDFOREACH (flag_var)  
+
+    if (MSVC)
+        # Replace /MT to /MD flag
+    	# Replace /O2 to /O3 flag
+        FOREACH (flag_var CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+                CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+		        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+		                CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+            STRING(REGEX REPLACE "/MT" "/MD" ${flag_var} "${${flag_var}}")
+        	STRING(REGEX REPLACE "/O2" "/Ox" ${flag_var} "${${flag_var}}")
+        ENDFOREACH (flag_var)      
+    endif ()
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}" CACHE STRING "Updated flags" FORCE)
+
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}" CACHE STRING "Updated flags" FORCE)
+    set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}" CACHE STRING "Updated flags" FORCE)
+
+ENDMACRO(ADD_EXTRA_COMPILATION_FLAGS)
--- a/contrib/cmake/CMakeModules/CompareVersion.cmake
+++ b/contrib/cmake/CMakeModules/CompareVersion.cmake
@ -0,0 +1,70 @@
+# Computes the realtionship between two version strings.  A version
+# string is a number delineated by '.'s such as 1.3.2 and 0.99.9.1.
+# You can feed version strings with different number of dot versions,
+# and the shorter version number will be padded with zeros: 9.2 <
+# 9.2.1 will actually compare 9.2.0 < 9.2.1.
+#
+# Input: a_in - value, not variable
+#        b_in - value, not variable
+#        result_out - variable with value:
+#                         -1 : a_in <  b_in
+#                          0 : a_in == b_in
+#                          1 : a_in >  b_in
+#
+# Written by James Bigler.
+MACRO(COMPARE_VERSION_STRINGS a_in b_in result_out)
+    # Since SEPARATE_ARGUMENTS using ' ' as the separation token,
+    # replace '.' with ' ' to allow easy tokenization of the string.
+    STRING(REPLACE "." " " a ${a_in})
+    STRING(REPLACE "." " " b ${b_in})
+    SEPARATE_ARGUMENTS(a)
+    SEPARATE_ARGUMENTS(b)
+
+    # Check the size of each list to see if they are equal.
+    LIST(LENGTH a a_length)
+    LIST(LENGTH b b_length)
+
+    # Pad the shorter list with zeros.
+
+    # Note that range needs to be one less than the length as the for
+    # loop is inclusive (silly CMake).
+    IF (a_length LESS b_length)
+        # a is shorter
+        SET(shorter a)
+        MATH(EXPR range "${b_length} - 1")
+        MATH(EXPR pad_range "${b_length} - ${a_length} - 1")
+    ELSE (a_length LESS b_length)
+        # b is shorter
+        SET(shorter b)
+        MATH(EXPR range "${a_length} - 1")
+        MATH(EXPR pad_range "${a_length} - ${b_length} - 1")
+    ENDIF (a_length LESS b_length)
+
+    # PAD out if we need to
+    IF (NOT pad_range LESS 0)
+        FOREACH (pad RANGE ${pad_range})
+            # Since shorter is an alias for b, we need to get to it by by dereferencing shorter.
+            LIST(APPEND ${shorter} 0)
+        ENDFOREACH (pad RANGE ${pad_range})
+    ENDIF (NOT pad_range LESS 0)
+
+    SET(result 0)
+    FOREACH (index RANGE ${range})
+        IF (result EQUAL 0)
+            # Only continue to compare things as long as they are equal
+            LIST(GET a ${index} a_version)
+            LIST(GET b ${index} b_version)
+            # LESS
+            IF (a_version LESS b_version)
+                SET(result -1)
+            ENDIF (a_version LESS b_version)
+            # GREATER
+            IF (a_version GREATER b_version)
+                SET(result 1)
+            ENDIF (a_version GREATER b_version)
+        ENDIF (result EQUAL 0)
+    ENDFOREACH (index)
+
+    # Copy out the return result
+    SET(${result_out} ${result})
+ENDMACRO(COMPARE_VERSION_STRINGS) 
--- a/contrib/cmake/cmake_uninstall.cmake.in
+++ b/contrib/cmake/cmake_uninstall.cmake.in
@ -0,0 +1,22 @@
+ 
+if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
+endif(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    exec_program(
+      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    if(NOT "${rm_retval}" STREQUAL 0)
+      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+    endif(NOT "${rm_retval}" STREQUAL 0)
+  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+  endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+endforeach(file)
--- a/contrib/cmake/lib/CMakeLists.txt
+++ b/contrib/cmake/lib/CMakeLists.txt
@ -0,0 +1,213 @@
+# ################################################################
+# zstd - Makefile
+# Copyright (C) Yann Collet 2014-2015
+# 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 :
+#  - zstd source repository : https://github.com/Cyan4973/zstd
+#  - Public forum : https://groups.google.com/forum/#!forum/lz4c
+# ################################################################
+
+IF (USE_DEPRECATED_CODE_STYLE)
+    IF (POLICY CMP0021)
+        cmake_policy(SET CMP0021 OLD)
+    ENDIF ()
+ENDIF (USE_DEPRECATED_CODE_STYLE)
+
+# Get library version based on information from input content (use regular exp)
+function(GetLibraryVersion _content _outputVar1 _outputVar2 _outputVar3)
+    string(REGEX MATCHALL ".*define ZSTD_VERSION_MAJOR+.* ([0-9]+).*define ZSTD_VERSION_MINOR+.* ([0-9]+).*define ZSTD_VERSION_RELEASE+.* ([0-9]+)" VERSION_REGEX "${_content}")
+    SET(${_outputVar1} ${CMAKE_MATCH_1} PARENT_SCOPE)
+    SET(${_outputVar2} ${CMAKE_MATCH_2} PARENT_SCOPE)
+    SET(${_outputVar3} ${CMAKE_MATCH_3} PARENT_SCOPE)
+endfunction()
+
+PROJECT(libzstd)
+
+SET(CMAKE_INCLUDE_CURRENT_DIR TRUE)
+
+# Define project root directory
+SET(ROOT_DIR ../../..)
+
+# Define library directory, where sources and header files are located
+SET(LIBRARY_DIR ${ROOT_DIR}/lib)
+INCLUDE_DIRECTORIES(${LIBRARY_DIR})
+
+# Read file content
+FILE(READ ${LIBRARY_DIR}/zstd.h HEADER_CONTENT)
+
+# Parse version
+GetLibraryVersion("${HEADER_CONTENT}" LIBVER_MAJOR LIBVER_MINOR LIBVER_RELEASE)
+MESSAGE("ZSTD VERSION ${LIBVER_MAJOR}.${LIBVER_MINOR}.${LIBVER_RELEASE}")
+
+SET(Sources
+        ${LIBRARY_DIR}/fse.c
+        ${LIBRARY_DIR}/huff0.c
+        ${LIBRARY_DIR}/zstd_buffered.c
+        ${LIBRARY_DIR}/zstd_compress.c
+        ${LIBRARY_DIR}/zstd_decompress.c)
+
+SET(Headers
+        ${LIBRARY_DIR}/bitstream.h
+        ${LIBRARY_DIR}/error.h
+        ${LIBRARY_DIR}/fse.h
+        ${LIBRARY_DIR}/fse_static.h
+        ${LIBRARY_DIR}/huff0.h
+        ${LIBRARY_DIR}/huff0_static.h
+        ${LIBRARY_DIR}/mem.h
+        ${LIBRARY_DIR}/zstd_buffered_static.h
+        ${LIBRARY_DIR}/zstd_buffered.h
+        ${LIBRARY_DIR}/zstd_internal.h
+        ${LIBRARY_DIR}/zstd_static.h
+        ${LIBRARY_DIR}/zstd.h)
+
+IF (ZSTD_LEGACY_SUPPORT)
+    SET(LIBRARY_LEGACY_DIR ${LIBRARY_DIR}/legacy)
+    INCLUDE_DIRECTORIES(${LIBRARY_LEGACY_DIR})
+
+    SET(Sources ${Sources}
+            ${LIBRARY_LEGACY_DIR}/zstd_v01.c
+            ${LIBRARY_LEGACY_DIR}/zstd_v02.c
+            ${LIBRARY_LEGACY_DIR}/zstd_v03.c)
+
+    SET(Headers ${Headers}
+            ${LIBRARY_LEGACY_DIR}/zstd_legacy.h
+            ${LIBRARY_LEGACY_DIR}/zstd_v01.h
+            ${LIBRARY_LEGACY_DIR}/zstd_v02.h
+            ${LIBRARY_LEGACY_DIR}/zstd_v03.h)
+ENDIF (ZSTD_LEGACY_SUPPORT)
+
+IF (MSVC)
+    SET(MSVC_RESOURCE_DIR ${ROOT_DIR}/visual/2013/zstdlib)
+    SET(PlatformDependResources ${MSVC_RESOURCE_DIR}/resource.h ${MSVC_RESOURCE_DIR}/zstdlib.rc)
+ENDIF (MSVC)
+
+# Split project to static and shared libraries build
+ADD_LIBRARY(libzstd_static STATIC ${Sources} ${Headers} ${PlatformDependResources})
+ADD_LIBRARY(libzstd_shared SHARED ${Sources} ${Headers} ${PlatformDependResources})
+
+# Add specific compile definitions for MSVC project
+IF (MSVC)
+    SET_TARGET_PROPERTIES(libzstd_static PROPERTIES COMPILE_DEFINITIONS "ZSTD_HEAPMODE=0;_CRT_SECURE_NO_WARNINGS")
+    SET_TARGET_PROPERTIES(libzstd_shared PROPERTIES COMPILE_DEFINITIONS "ZSTD_DLL_EXPORT=1;ZSTD_HEAPMODE=0;_CONSOLE;_CRT_SECURE_NO_WARNINGS")
+ENDIF (MSVC)
+
+IF (NOT USE_DEPRECATED_CODE_STYLE)
+    TARGET_INCLUDE_DIRECTORIES(libzstd_static PUBLIC ${LIBRARY_DIR})
+    TARGET_INCLUDE_DIRECTORIES(libzstd_shared PUBLIC ${LIBRARY_DIR})
+ENDIF (NOT USE_DEPRECATED_CODE_STYLE)
+
+IF (ZSTD_LEGACY_SUPPORT)
+    IF (NOT USE_DEPRECATED_CODE_STYLE)
+        TARGET_INCLUDE_DIRECTORIES(libzstd_static PUBLIC ${LIBRARY_LEGACY_DIR})
+        TARGET_INCLUDE_DIRECTORIES(libzstd_shared PUBLIC ${LIBRARY_LEGACY_DIR})
+    ENDIF (NOT USE_DEPRECATED_CODE_STYLE)
+ENDIF (ZSTD_LEGACY_SUPPORT)
+
+# Define library base name
+IF (UNIX)
+    SET(LIBRARY_BASE_NAME libzstd)
+ELSEIF (MSVC)
+    SET(LIBRARY_BASE_NAME zstdlib)
+ELSE ()
+    MESSAGE(FATAL_ERROR "Unsupported build type")
+ENDIF (UNIX)
+
+# Define static and shared library names
+SET(STATIC_LIBRARY_OUTPUT_NAME ${LIBRARY_BASE_NAME})
+SET(SHARED_LIBRARY_OUTPUT_NAME ${LIBRARY_BASE_NAME}.${LIBVER_MAJOR}.${LIBVER_MINOR}.${LIBVER_RELEASE})
+
+IF (MSVC)
+    IF (CMAKE_SIZEOF_VOID_P MATCHES "8")
+        SET(STATIC_LIBRARY_OUTPUT_NAME ${STATIC_LIBRARY_OUTPUT_NAME}_x64)
+        SET(SHARED_LIBRARY_OUTPUT_NAME ${SHARED_LIBRARY_OUTPUT_NAME}_x64)
+    ELSE ()
+        SET(STATIC_LIBRARY_OUTPUT_NAME ${STATIC_LIBRARY_OUTPUT_NAME}_x86)
+        SET(SHARED_LIBRARY_OUTPUT_NAME ${SHARED_LIBRARY_OUTPUT_NAME}_x86)
+    ENDIF (CMAKE_SIZEOF_VOID_P MATCHES "8")
+ENDIF (MSVC)
+
+SET_TARGET_PROPERTIES(
+        libzstd_static
+        PROPERTIES
+        PREFIX ""
+        OUTPUT_NAME ${STATIC_LIBRARY_OUTPUT_NAME})
+
+SET_TARGET_PROPERTIES(
+        libzstd_shared
+        PROPERTIES
+        PREFIX ""
+        OUTPUT_NAME ${SHARED_LIBRARY_OUTPUT_NAME})
+
+IF (UNIX)
+    SET(PREFIX /usr/local)
+    SET(INSTALL_LIBRARY_DIR ${PREFIX}/lib)
+    SET(INSTALL_INCLUDE_DIR ${PREFIX}/include)
+
+    # install target
+    INSTALL(FILES ${LIBRARY_DIR}/zstd.h DESTINATION ${INSTALL_INCLUDE_DIR})
+    INSTALL(TARGETS libzstd_static DESTINATION ${INSTALL_LIBRARY_DIR})
+    INSTALL(TARGETS libzstd_shared LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR})
+
+    # Create symlinks and setup this files
+    SET(SHARED_LIBRARY_LINK ${SHARED_LIBRARY_OUTPUT_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX})
+    SET(SHARED_LIBRARY_SYMLINK1 ${LIBRARY_BASE_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX})
+    SET(SHARED_LIBRARY_SYMLINK2 ${LIBRARY_BASE_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}.${LIBVER_MAJOR})
+
+    SET(SHARED_LIBRARY_LINK_PATH ${CMAKE_CURRENT_BINARY_DIR}/${SHARED_LIBRARY_LINK})
+    SET(SHARED_LIBRARY_SYMLINK1_PATH ${CMAKE_CURRENT_BINARY_DIR}/${SHARED_LIBRARY_SYMLINK1})
+    SET(SHARED_LIBRARY_SYMLINK2_PATH ${CMAKE_CURRENT_BINARY_DIR}/${SHARED_LIBRARY_SYMLINK2})
+
+    if (EXISTS ${SHARED_LIBRARY_SYMLINK1_PATH})
+        FILE(REMOVE ${SHARED_LIBRARY_SYMLINK1_PATH})
+    endif (EXISTS ${SHARED_LIBRARY_SYMLINK1_PATH})
+
+    if (EXISTS ${SHARED_LIBRARY_SYMLINK2_PATH})
+        FILE(REMOVE ${SHARED_LIBRARY_SYMLINK2_PATH})
+    endif (EXISTS ${SHARED_LIBRARY_SYMLINK2_PATH})
+
+    ADD_CUSTOM_COMMAND(TARGET libzstd_shared POST_BUILD
+            COMMAND ln -s ${SHARED_LIBRARY_LINK} ${SHARED_LIBRARY_SYMLINK1}
+            DEPENDS ${SHARED_LIBRARY_LINK_PATH}
+            COMMENT "Generating symbolic link")
+
+    ADD_CUSTOM_COMMAND(TARGET libzstd_shared POST_BUILD
+            COMMAND ln -s ${SHARED_LIBRARY_LINK} ${SHARED_LIBRARY_SYMLINK2}
+            DEPENDS ${SHARED_LIBRARY_LINK_PATH}
+            COMMENT "Generating symbolic link")
+
+    INSTALL(FILES ${SHARED_LIBRARY_SYMLINK1_PATH} DESTINATION ${INSTALL_LIBRARY_DIR})
+    INSTALL(FILES ${SHARED_LIBRARY_SYMLINK2_PATH} DESTINATION ${INSTALL_LIBRARY_DIR})
+
+    # uninstall target
+    CONFIGURE_FILE(
+            "${CMAKE_SOURCE_DIR}/cmake_uninstall.cmake.in"
+            "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake"
+            IMMEDIATE @ONLY)
+
+    ADD_CUSTOM_TARGET(uninstall
+            COMMAND ${CMAKE_COMMAND} -P ${CMAKE_BINARY_DIR}/cmake_uninstall.cmake)
+ENDIF (UNIX)
--- a/contrib/cmake/programs/CMakeLists.txt
+++ b/contrib/cmake/programs/CMakeLists.txt
@ -0,0 +1,84 @@
+# ################################################################
+# zstd - Makefile
+# Copyright (C) Yann Collet 2014-2015
+# 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 :
+#  - zstd source repository : https://github.com/Cyan4973/zstd
+#  - Public forum : https://groups.google.com/forum/#!forum/lz4c
+# ################################################################
+
+PROJECT(programs)
+
+SET(CMAKE_INCLUDE_CURRENT_DIR TRUE)
+
+# Define project root directory
+SET(ROOT_DIR ../../..)
+
+# Define programs directory, where sources and header files are located
+SET(PROGRAMS_DIR ${ROOT_DIR}/programs)
+INCLUDE_DIRECTORIES(${PROGRAMS_DIR})
+
+IF (USE_DEPRECATED_CODE_STYLE)
+    # Define library directory, where sources and header files are located
+    SET(LIBRARY_DIR ${ROOT_DIR}/lib)
+    INCLUDE_DIRECTORIES(${LIBRARY_DIR})
+ENDIF (USE_DEPRECATED_CODE_STYLE)
+
+IF (ZSTD_LEGACY_SUPPORT)
+    SET(PROGRAMS_LEGACY_DIR ${PROGRAMS_DIR}/legacy)
+    INCLUDE_DIRECTORIES(${PROGRAMS_LEGACY_DIR})
+
+    IF (USE_DEPRECATED_CODE_STYLE)
+        INCLUDE_DIRECTORIES(${LIBRARY_DIR}/legacy)
+    ENDIF (USE_DEPRECATED_CODE_STYLE)
+
+    SET(ZSTD_FILEIO_LEGACY ${PROGRAMS_LEGACY_DIR}/fileio_legacy.c)
+ENDIF (ZSTD_LEGACY_SUPPORT)
+
+ADD_EXECUTABLE(zstd ${PROGRAMS_DIR}/zstdcli.c ${PROGRAMS_DIR}/fileio.c ${PROGRAMS_DIR}/bench.c ${PROGRAMS_DIR}/xxhash.c ${PROGRAMS_DIR}/datagen.c ${ZSTD_FILEIO_LEGACY})
+TARGET_LINK_LIBRARIES(zstd libzstd_static)
+
+ADD_EXECUTABLE(fullbench ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/fullbench.c)
+TARGET_LINK_LIBRARIES(fullbench libzstd_static)
+
+ADD_EXECUTABLE(fuzzer ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/xxhash.c ${PROGRAMS_DIR}/fuzzer.c)
+TARGET_LINK_LIBRARIES(fuzzer libzstd_static)
+
+IF (UNIX)
+    ADD_EXECUTABLE(zstd-noBench ${PROGRAMS_DIR}/zstdcli.c ${PROGRAMS_DIR}/fileio.c ${ZSTD_FILEIO_LEGACY})
+    TARGET_LINK_LIBRARIES(zstd-noBench libzstd_static)
+    SET_TARGET_PROPERTIES(zstd-noBench PROPERTIES COMPILE_DEFINITIONS "ZSTD_NOBENCH")
+
+    ADD_EXECUTABLE(zbufftest ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/xxhash.c ${PROGRAMS_DIR}/zbufftest.c)
+    TARGET_LINK_LIBRARIES(zbufftest libzstd_static)
+
+    ADD_EXECUTABLE(paramgrill ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/xxhash.c ${PROGRAMS_DIR}/paramgrill.c)
+    TARGET_LINK_LIBRARIES(paramgrill libzstd_static m) #m is math library
+
+    ADD_EXECUTABLE(datagen ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/datagencli.c)
+    TARGET_LINK_LIBRARIES(datagen libzstd_static)
+ENDIF (UNIX)
--- a/lib/zstd_decompress.c
+++ b/lib/zstd_decompress.c
@ -35,13 +35,12 @@
 *****************************************************************/
 /*!
 * HEAPMODE :
- * Select how default compression functions will allocate memory for their hash table,
- * in memory stack (0, fastest), or in memory heap (1, requires malloc())
- * Note that compression context is fairly large, as a consequence heap memory is recommended.
+ * Select how default decompression function ZSTD_decompress() will allocate memory,
+ * in memory stack (0), or in memory heap (1, requires malloc())
 */
 #ifndef ZSTD_HEAPMODE
 #  define ZSTD_HEAPMODE 1
-#endif /* ZSTD_HEAPMODE */
+#endif

 /*!
 *  LEGACY_SUPPORT :
@ -790,8 +789,17 @@ size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize, const

 size_t ZSTD_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)
 {
+#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE==1)
+    size_t regenSize;
+    ZSTD_DCtx* dctx = ZSTD_createDCtx();
+    if (dctx==NULL) return ERROR(memory_allocation);
+    regenSize = ZSTD_decompressDCtx(dctx, dst, maxDstSize, src, srcSize);
+    ZSTD_freeDCtx(dctx);
+    return regenSize;
+#else
    ZSTD_DCtx dctx;
    return ZSTD_decompressDCtx(&dctx, dst, maxDstSize, src, srcSize);
+#endif // defined
 }