fabi/Snappy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Redo CMake configuration.

Browse Source 
The style was changed to match the official manual [1], the install
configuration was simplified and now matches the official packaging
guide [2], and the config files use the CMake-specific variable syntax
${VAR} instead of the autoconf-compatible syntax @VAR@, as documented in
[3]. The public header files are declared as such (for CMake 3.3+), and
the generated headers are included in the library target definition.

The tests are only built if SNAPPY_BUILD_TESTS (default ON) is true, so
zippy can be easily used in projects that add_subdirectory() its source
code directly, instead of using find_package().

[1] https://cmake.org/cmake/help/git-master/manual/cmake-language.7.html
[2] https://cmake.org/cmake/help/git-master/manual/cmake-packages.7.html
[3] https://cmake.org/cmake/help/git-master/command/configure_file.html
This commit is contained in:
costan
2017-07-28 09:55:21 -07:00
committed by Victor Costan
parent e4de6ce087
commit be6dc3db83
6 changed files with 158 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.appveyor.yml
View File

@@ -31,11 +31,11 @@ build_script:
- mkdir out - mkdir out
- cd out - cd out
- if "%platform%"=="x64" set CMAKE_GENERATOR=%CMAKE_GENERATOR% Win64 - if "%platform%"=="x64" set CMAKE_GENERATOR=%CMAKE_GENERATOR% Win64
- cmake --version
- cmake .. -G "%CMAKE_GENERATOR%" - cmake .. -G "%CMAKE_GENERATOR%"
-DCMAKE_CONFIGURATION_TYPES="%CONFIGURATION%" -DCMAKE_CONFIGURATION_TYPES="%CONFIGURATION%"
- cmake --build . --config %CONFIGURATION% - cmake --build . --config %CONFIGURATION%
- cd .. - cd ..
- cmake --version
test_script: test_script:
- out\%CONFIGURATION%\snappy-unittest - out\%CONFIGURATION%\snappy_unittest

4
.travis.yml
View File

@@ -47,13 +47,13 @@ install:
- echo ${CC} - echo ${CC}
- echo ${CXX} - echo ${CXX}
- ${CXX} --version - ${CXX} --version
- cmake --version
before_script: before_script:
- mkdir -p build && cd build - mkdir -p build && cd build
- cmake .. -DCMAKE_BUILD_TYPE=$BUILD_TYPE - cmake .. -DCMAKE_BUILD_TYPE=$BUILD_TYPE
- cmake --build . - cmake --build .
- cd .. - cd ..
- cmake --version
script: script:
- build/snappy-unittest - build/snappy_unittest

262
CMakeLists.txt
View File

@@ -1,147 +1,165 @@
CMAKE_MINIMUM_REQUIRED(VERSION 3.1) cmake_minimum_required(VERSION 3.1)
PROJECT(Snappy VERSION 1.1.6 LANGUAGES C CXX) project(Snappy VERSION 1.1.6 LANGUAGES C CXX)
# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to make
# it prominent in the GUI. # it prominent in the GUI.
OPTION (BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF) option(BUILD_SHARED_LIBS "Build shared libraries(DLLs)." OFF)
SET(CMAKE_INCLUDE_CURRENT_DIR ON) option(SNAPPY_BUILD_TESTS "Build Snappy's own tests." ON)
INCLUDE(CheckIncludeFiles) include(TestBigEndian)
INCLUDE(CheckLibraryExists) test_big_endian(WORDS_BIG_ENDIAN)
INCLUDE(CheckCXXSourceCompiles) if(WORDS_BIG_ENDIAN)
INCLUDE(CheckSymbolExists) add_definitions(-DWORDS_BIGENDIAN=1)
INCLUDE(TestBigEndian) endif(WORDS_BIG_ENDIAN)
INCLUDE(CMakePackageConfigHelpers)
TEST_BIG_ENDIAN(WORDS_BIG_ENDIAN) include(CheckIncludeFile)
IF (WORDS_BIG_ENDIAN) check_include_file("byteswap.h" HAVE_BYTESWAP_H)
MESSAGE(STATUS "Building on big endian system") check_include_file("stddef.h" HAVE_STDDEF_H)
ADD_DEFINITIONS(-DWORDS_BIGENDIAN=1) check_include_file("stdint.h" HAVE_STDINT_H)
ENDIF (WORDS_BIG_ENDIAN) check_include_file("sys/endian.h" HAVE_SYS_ENDIAN_H)
check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
check_include_file("sys/resource.h" HAVE_SYS_RESOURCE_H)
check_include_file("sys/time.h" HAVE_SYS_TIME_H)
check_include_file("sys/uio.h" HAVE_SYS_UIO_H)
check_include_file("windows.h" HAVE_WINDOWS_H)
CHECK_INCLUDE_FILES("byteswap.h" HAVE_BYTESWAP_H) include(CheckLibraryExists)
CHECK_INCLUDE_FILES("stddef.h" HAVE_STDDEF_H) check_library_exists(z zlibVersion "" HAVE_LIBZ)
CHECK_INCLUDE_FILES("stdint.h" HAVE_STDINT_H) check_library_exists(lzo2 lzo1x_1_15_compress "" HAVE_LIBLZO2)
CHECK_INCLUDE_FILES("sys/endian.h" HAVE_SYS_ENDIAN_H)
CHECK_INCLUDE_FILES("sys/mman.h" HAVE_SYS_MMAN_H)
CHECK_INCLUDE_FILES("sys/resource.h" HAVE_SYS_RESOURCE_H)
CHECK_INCLUDE_FILES("sys/time.h" HAVE_SYS_TIME_H)
CHECK_INCLUDE_FILES("sys/uio.h" HAVE_SYS_UIO_H)
CHECK_INCLUDE_FILES("windows.h" HAVE_WINDOWS_H)
IF (NOT HAVE_SYS_UIO_H) include(CheckCXXSourceCompiles)
SET(HAVE_SYS_UIO_H 0) check_cxx_source_compiles(
ENDIF (NOT HAVE_SYS_UIO_H) "int main(void) { return __builtin_expect(0, 1); }" HAVE_BUILTIN_EXPECT)
IF (NOT HAVE_STDINT_H) check_cxx_source_compiles(
SET(HAVE_STDINT_H 0) "int main(void) { return __builtin_ctzll(0); }" HAVE_BUILTIN_CTZ)
ENDIF (NOT HAVE_STDINT_H)
IF (NOT HAVE_STDDEF_H) include(CheckSymbolExists)
SET(HAVE_STDDEF_H 0) check_symbol_exists("mmap" "sys/mman.h" HAVE_FUNC_MMAP)
ENDIF (NOT HAVE_STDDEF_H)
CHECK_LIBRARY_EXISTS(z zlibVersion "" HAVE_LIBZ) find_package(GTest QUIET)
CHECK_LIBRARY_EXISTS(lzo2 lzo1x_1_15_compress "" HAVE_LIBLZO2) if(GTEST_FOUND)
set(HAVE_GTEST 1)
endif(GTEST_FOUND)
CHECK_SYMBOL_EXISTS(mmap sys/mman.h HAVE_FUNC_MMAP) find_package(Gflags QUIET)
if(GFLAGS_FOUND)
set(HAVE_GFLAGS 1)
endif(GFLAGS_FOUND)
CHECK_CXX_SOURCE_COMPILES("int main(void) { return __builtin_expect(0, 1); }" configure_file(
HAVE_BUILTIN_EXPECT) "${PROJECT_SOURCE_DIR}/cmake/config.h.in"
"${PROJECT_BINARY_DIR}/config.h"
)
CHECK_CXX_SOURCE_COMPILES("int main(void) { return __builtin_ctzll(0); }" # We don't want to define HAVE_ macros in public headers. Instead, we use
HAVE_BUILTIN_CTZ) # CMake's variable substitution with 0/1 variables, which will be seen by the
# preprocessor as constants.
set(HAVE_STDINT_H_01 ${HAVE_STDINT_H})
set(HAVE_STDDEF_H_01 ${HAVE_STDDEF_H})
set(HAVE_SYS_UIO_H_01 ${HAVE_SYS_UIO_H})
if(NOT HAVE_STDINT_H_01)
set(HAVE_STDINT_H_01 0)
endif(NOT HAVE_STDINT_H_01)
if(NOT HAVE_STDDEF_H_01)
set(HAVE_STDDEF_H_01 0)
endif(NOT HAVE_STDDEF_H_01)
if(NOT HAVE_SYS_UIO_H_01)
set(HAVE_SYS_UIO_H_01 0)
endif(NOT HAVE_SYS_UIO_H_01)
FIND_PACKAGE(GTest QUIET) configure_file(
IF(GTEST_FOUND) "${PROJECT_SOURCE_DIR}/snappy-stubs-public.h.in"
SET(HAVE_GTEST 1) "${PROJECT_BINARY_DIR}/snappy-stubs-public.h")
ENDIF()
FIND_PACKAGE(Gflags QUIET) add_library(snappy "")
IF(GFLAGS_FOUND) target_sources(snappy
SET(HAVE_GFLAGS 1) PRIVATE
ENDIF() "${PROJECT_SOURCE_DIR}/snappy-internal.h"
"${PROJECT_SOURCE_DIR}/snappy-stubs-internal.h"
"${PROJECT_SOURCE_DIR}/snappy-c.cc"
"${PROJECT_SOURCE_DIR}/snappy-sinksource.cc"
"${PROJECT_SOURCE_DIR}/snappy-stubs-internal.cc"
"${PROJECT_SOURCE_DIR}/snappy.cc"
"${PROJECT_BINARY_DIR}/config.h"
CONFIGURE_FILE(${Snappy_SOURCE_DIR}/cmake/config.h.in config.h) # Only CMake 3.3+ supports PUBLIC sources in targets exported by "install".
$<$<VERSION_GREATER:CMAKE_VERSION,3.2>:PUBLIC>
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-c.h>
$<INSTALL_INTERFACE:include/snappy-c.h>
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy-sinksource.h>
$<INSTALL_INTERFACE:include/snappy-sinksource.h>
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/snappy.h>
$<INSTALL_INTERFACE:include/snappy.h>
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/snappy-stubs-public.h>
$<INSTALL_INTERFACE:include/snappy-stubs-public.h>
)
target_include_directories(snappy
PUBLIC
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
$<INSTALL_INTERFACE:include>
)
set_target_properties(snappy
PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR})
# Configure snappy-stubs-public.h.in target_compile_definitions(snappy PRIVATE -DHAVE_CONFIG_H)
SET(ac_cv_have_stdint_h ${HAVE_STDINT_H}) if(BUILD_SHARED_LIBS)
SET(ac_cv_have_stddef_h ${HAVE_STDDEF_H}) set_target_properties(snappy PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON)
SET(ac_cv_have_sys_uio_h ${HAVE_SYS_UIO_H}) endif(BUILD_SHARED_LIBS)
CONFIGURE_FILE(${Snappy_SOURCE_DIR}/snappy-stubs-public.h.in
snappy-stubs-public.h)
IF (WIN32) if(SNAPPY_BUILD_TESTS)
ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS) enable_testing()
ENDIF (WIN32)
# Define the main library. add_executable(snappy_unittest "")
ADD_LIBRARY(snappy target_sources(snappy_unittest
snappy-c.cc PRIVATE
snappy-c.h "${PROJECT_SOURCE_DIR}/snappy_unittest.cc"
snappy-sinksource.cc "${PROJECT_SOURCE_DIR}/snappy-test.cc"
snappy-sinksource.h )
snappy-stubs-internal.cc target_compile_definitions(snappy_unittest PRIVATE -DHAVE_CONFIG_H)
snappy-stubs-public.h target_link_libraries(snappy_unittest snappy ${GFLAGS_LIBRARIES})
snappy.cc
snappy.h)
TARGET_COMPILE_DEFINITIONS(snappy PRIVATE -DHAVE_CONFIG_H) if(HAVE_LIBZ)
target_link_libraries(snappy_unittest z)
endif(HAVE_LIBZ)
if(HAVE_LIBLZO2)
target_link_libraries(snappy_unittest lzo2)
endif(HAVE_LIBLZO2)
IF (BUILD_SHARED_LIBS) target_include_directories(snappy_unittest
SET_TARGET_PROPERTIES(snappy PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON) BEFORE PRIVATE
ENDIF (BUILD_SHARED_LIBS) "${PROJECT_SOURCE_DIR}"
"${GTEST_INCLUDE_DIRS}"
"${GFLAGS_INCLUDE_DIRS}"
)
INSTALL(FILES snappy.h add_test(
snappy-c.h NAME snappy_unittest
snappy-sinksource.h WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
${Snappy_BINARY_DIR}/snappy-stubs-public.h COMMAND "${PROJECT_BINARY_DIR}/snappy_unittest")
DESTINATION include) endif(SNAPPY_BUILD_TESTS)
INSTALL(TARGETS snappy install(TARGETS snappy EXPORT SnappyTargets DESTINATION lib)
EXPORT SnappyTargets install(
RUNTIME DESTINATION bin FILES
LIBRARY DESTINATION lib "${PROJECT_SOURCE_DIR}/snappy-c.h"
ARCHIVE DESTINATION lib) "${PROJECT_SOURCE_DIR}/snappy-sinksource.h"
INSTALL(EXPORT SnappyTargets NAMESPACE Snappy:: DESTINATION lib/cmake/Snappy) "${PROJECT_SOURCE_DIR}/snappy.h"
"${PROJECT_BINARY_DIR}/snappy-stubs-public.h"
DESTINATION include
)
SET_TARGET_PROPERTIES(snappy PROPERTIES VERSION ${PROJECT_VERSION} include(CMakePackageConfigHelpers)
SOVERSION ${PROJECT_VERSION_MAJOR}) write_basic_package_version_file(
"${PROJECT_BINARY_DIR}/SnappyConfigVersion.cmake"
SET(INCLUDE_INSTALL_DIR include) COMPATIBILITY SameMajorVersion
SET(LIBRARY_INSTALL_DIR lib) )
SET(BINARY_INSTALL_DIR bin) install(EXPORT SnappyTargets NAMESPACE Snappy:: DESTINATION lib/cmake/Snappy)
install(
CONFIGURE_PACKAGE_CONFIG_FILE(cmake/SnappyConfig.cmake.in FILES
${Snappy_BINARY_DIR}/SnappyConfig.cmake "${PROJECT_SOURCE_DIR}/cmake/SnappyConfig.cmake"
INSTALL_DESTINATION lib/Snappy/cmake "${PROJECT_BINARY_DIR}/SnappyConfigVersion.cmake"
PATH_VARS INCLUDE_INSTALL_DIR LIBRARY_INSTALL_DIR BINARY_INSTALL_DIR DESTINATION lib/cmake/Snappy
) )
WRITE_BASIC_PACKAGE_VERSION_FILE(${Snappy_BINARY_DIR}/SnappyConfigVersion.cmake
COMPATIBILITY SameMajorVersion)
INSTALL(FILES ${Snappy_BINARY_DIR}/SnappyConfig.cmake
${Snappy_BINARY_DIR}/SnappyConfigVersion.cmake
DESTINATION lib/cmake)
ENABLE_TESTING()
IF (HAVE_LIBZ)
LIST(APPEND COMPRESSION_LIBS z)
ENDIF (HAVE_LIBZ)
IF (HAVE_LIBLZO2)
LIST(APPEND COMPRESSION_LIBS lzo2)
ENDIF (HAVE_LIBLZO2)
ADD_EXECUTABLE(snappy-unittest snappy_unittest.cc snappy-test.cc)
TARGET_COMPILE_DEFINITIONS(snappy-unittest PRIVATE -DHAVE_CONFIG_H)
TARGET_LINK_LIBRARIES(snappy-unittest snappy ${COMPRESSION_LIBS}
${GFLAGS_LIBRARIES})
TARGET_INCLUDE_DIRECTORIES(snappy-unittest BEFORE PRIVATE ${Snappy_SOURCE_DIR}
${GTEST_INCLUDE_DIRS} ${GFLAGS_INCLUDE_DIRS})
ADD_TEST(NAME snappy-unittest
WORKING_DIRECTORY ${Snappy_SOURCE_DIR}
COMMAND ${Snappy_BINARY_DIR}/snappy-unittest)

1
cmake/SnappyConfig.cmake Normal file
View File

@@ -0,0 +1 @@
include("${CMAKE_CURRENT_LIST_DIR}/SnappyTargets.cmake")

9
cmake/SnappyConfig.cmake.in
View File

@@ -1,9 +0,0 @@
set(SNAPPY_VERSION @SNAPPY_MAJOR@.@SNAPPY_MINOR@.@SNAPPY_PATCHLEVEL@)
@PACKAGE_INIT@
set_and_check(SNAPPY_INCLUDE_DIR "@PACKAGE_INCLUDE_INSTALL_DIR@")
set_and_check(SNAPPY_LIBRARY_DIR "@PACKAGE_LIBRARY_INSTALL_DIR@")
set_and_check(SNAPPY_BINARY_DIR "@PACKAGE_BINARY_INSTALL_DIR@")
check_required_components(SNAPPY)

26
snappy-stubs-public.h.in
View File

@@ -36,21 +36,21 @@
#ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_ #ifndef THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
#define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_ #define THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_PUBLIC_H_
#if @ac_cv_have_stdint_h@ #if ${HAVE_STDINT_H_01} // HAVE_STDINT_H
#include <stdint.h> #include <stdint.h>
#endif #endif // HAVE_STDDEF_H
#if @ac_cv_have_stddef_h@ #if ${HAVE_STDDEF_H_01} // HAVE_STDDEF_H
#include <stddef.h> #include <stddef.h>
#endif #endif // HAVE_STDDEF_H
#if @ac_cv_have_sys_uio_h@ #if ${HAVE_SYS_UIO_H_01} // HAVE_SYS_UIO_H
#include <sys/uio.h> #include <sys/uio.h>
#endif #endif // HAVE_SYS_UIO_H
#define SNAPPY_MAJOR @SNAPPY_MAJOR@ #define SNAPPY_MAJOR ${SNAPPY_MAJOR}
#define SNAPPY_MINOR @SNAPPY_MINOR@ #define SNAPPY_MINOR ${SNAPPY_MINOR}
#define SNAPPY_PATCHLEVEL @SNAPPY_PATCHLEVEL@ #define SNAPPY_PATCHLEVEL ${SNAPPY_PATCHLEVEL}
#define SNAPPY_VERSION \ #define SNAPPY_VERSION \
((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL) ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL)
@@ -58,7 +58,7 @@
namespace snappy { namespace snappy {
#if @ac_cv_have_stdint_h@ #if ${HAVE_STDINT_H_01} // HAVE_STDINT_H
typedef int8_t int8; typedef int8_t int8;
typedef uint8_t uint8; typedef uint8_t uint8;
typedef int16_t int16; typedef int16_t int16;
@@ -76,18 +76,18 @@ typedef int int32;
typedef unsigned int uint32; typedef unsigned int uint32;
typedef long long int64; typedef long long int64;
typedef unsigned long long uint64; typedef unsigned long long uint64;
#endif #endif // HAVE_STDINT_H
typedef std::string string; typedef std::string string;
#if !@ac_cv_have_sys_uio_h@ #if !${HAVE_SYS_UIO_H_01} // !HAVE_SYS_UIO_H
// Windows does not have an iovec type, yet the concept is universally useful. // Windows does not have an iovec type, yet the concept is universally useful.
// It is simple to define it ourselves, so we put it inside our own namespace. // It is simple to define it ourselves, so we put it inside our own namespace.
struct iovec { struct iovec {
void* iov_base; void* iov_base;
size_t iov_len; size_t iov_len;
}; };
#endif #endif // !HAVE_SYS_UIO_H
} // namespace snappy } // namespace snappy