diff --git a/.gitignore b/.gitignore index 072fe39c..8641d7f9 100644 --- a/.gitignore +++ b/.gitignore @@ -37,4 +37,10 @@ ipch/ *.opendb *.opensdf *.sdf -*.cachefile \ No newline at end of file +*.cachefile + +# IDEA solution files +*.idea + +# Other files +.directory diff --git a/.travis.yml b/.travis.yml index 2d5a73a6..993695b8 100644 --- 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 \ No newline at end of file diff --git a/Makefile b/Makefile index 62ca6683..88de5d0d 100644 --- a/Makefile +++ b/Makefile @@ -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" diff --git a/NEWS b/NEWS index fff7bf04..9f3f8ce5 100644 --- a/NEWS +++ b/NEWS @@ -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() diff --git a/contrib/cmake/CMakeLists.txt b/contrib/cmake/CMakeLists.txt new file mode 100644 index 00000000..baa36c6a --- /dev/null +++ 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() diff --git a/contrib/cmake/CMakeModules/AddExtraCompilationFlags.cmake b/contrib/cmake/CMakeModules/AddExtraCompilationFlags.cmake new file mode 100644 index 00000000..2d59fabb --- /dev/null +++ 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) diff --git a/contrib/cmake/CMakeModules/CompareVersion.cmake b/contrib/cmake/CMakeModules/CompareVersion.cmake new file mode 100644 index 00000000..a9015759 --- /dev/null +++ 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) diff --git a/contrib/cmake/cmake_uninstall.cmake.in b/contrib/cmake/cmake_uninstall.cmake.in new file mode 100644 index 00000000..e3774dc1 --- /dev/null +++ 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) diff --git a/contrib/cmake/lib/CMakeLists.txt b/contrib/cmake/lib/CMakeLists.txt new file mode 100644 index 00000000..f533a5b8 --- /dev/null +++ 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) diff --git a/contrib/cmake/programs/CMakeLists.txt b/contrib/cmake/programs/CMakeLists.txt new file mode 100644 index 00000000..7904b682 --- /dev/null +++ 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) diff --git a/lib/zstd_decompress.c b/lib/zstd_decompress.c index 14918cb4..d11f6500 100644 --- 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 }