#

# CMakeLists.txt --- a simple "cmake" file for building LZO

#

# This file is part of the LZO data compression library.

#

# Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer

# All Rights Reserved.

#

#

# simple usage:

#     mkdir -p build && cd build && cmake .. && make

#

# another usage example:

#     mkdir -p build/release-i686

#     cd       build/release-i686

#     cmake ../.. -DENABLE_STATIC=0 -DENABLE_SHARED=1 \

#         -DCMAKE_C_COMPILER=gcc -DCMAKE_C_FLAGS="-m32 -march=i686" \

#         -DCMAKE_INSTALL_PREFIX=/opt/local/prefix-i686

#     make VERBOSE=1

#     make install

#

#

# init

#

cmake_minimum_required(VERSION 2.6 FATAL_ERROR)

# Disallow in-source builds. Note that you will still have to manually

# clean up a few files if you accidentally try an in-source build.

set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)

set(CMAKE_DISABLE_SOURCE_CHANGES  ON)

if(",${CMAKE_SOURCE_DIR}," STREQUAL ",${CMAKE_BINARY_DIR},")

    message(FATAL_ERROR "ERROR: In-source builds are not allowed.")

endif()

project(lzo C)

#

# configuration options

#

option(ENABLE_STATIC "Build static LZO library." ON)

option(ENABLE_SHARED "Build shared LZO library." OFF)

if(NOT CMAKE_BUILD_TYPE)

    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)

endif()

if(NOT CMAKE_INSTALL_PREFIX)

    set(CMAKE_INSTALL_PREFIX "/usr/local" CACHE PATH "" FORCE)

endif()

#

# targets

#

file(GLOB lzo_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.c")

list(SORT lzo_SOURCES)

if(NOT ENABLE_STATIC AND NOT ENABLE_SHARED)

    set(ENABLE_STATIC ON)

endif()

if(ENABLE_STATIC)

    add_library(lzo_static STATIC ${lzo_SOURCES})

    set_target_properties(lzo_static PROPERTIES OUTPUT_NAME lzo2)

endif()

if(ENABLE_SHARED)

    add_library(lzo_shared SHARED ${lzo_SOURCES})

    set_target_properties(lzo_shared PROPERTIES OUTPUT_NAME lzo2)

    # TODO: VERSION, SOVERSION

endif()

macro(lzo_add_executable t)

    add_executable(${t} ${ARGN})

    if(ENABLE_STATIC)

        target_link_libraries(${t} lzo_static)

    else()

        target_link_libraries(${t} lzo_shared)

    endif()

endmacro()

# main test driver

lzo_add_executable(lzotest  lzotest/lzotest.c)

# examples

lzo_add_executable(dict     examples/dict.c)

lzo_add_executable(lzopack  examples/lzopack.c)

lzo_add_executable(overlap  examples/overlap.c)

lzo_add_executable(precomp  examples/precomp.c)

lzo_add_executable(precomp2 examples/precomp2.c)

lzo_add_executable(simple   examples/simple.c)

if(0)

# some boring test programs

lzo_add_executable(align    tests/align.c)

lzo_add_executable(chksum   tests/chksum.c)

lzo_add_executable(promote  tests/promote.c)

lzo_add_executable(sizes    tests/sizes.c)

endif()

#

# compilation flags

#

include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

include_directories(${CMAKE_CURRENT_SOURCE_DIR})

include(CheckFunctionExists)

include(CheckIncludeFile)

include(CheckLibraryExists)

include(CheckSymbolExists)

include(CheckTypeSize)

include(TestBigEndian)

# Checks for header files

macro(lzo_check_include_file f var)

    check_include_file("${f}" "${var}")

    if(NOT ",${${var}}," STREQUAL ",,")

        add_definitions(-D${var}=1)

    endif()

endmacro()

lzo_check_include_file(stdint.h             HAVE_STDINT_H)

lzo_check_include_file(sys/stat.h           HAVE_SYS_STAT_H)

lzo_check_include_file(sys/types.h          HAVE_SYS_TYPES_H)

# Checks for typedefs and structures

macro(lzo_check_type_size type var)

    check_type_size("${type}" "${var}")

    if("${${var}}" MATCHES "^[0-9]+$")

        add_definitions(-D${var}=${${var}})

    endif()

endmacro()

lzo_check_type_size("short"                 SIZEOF_SHORT)

lzo_check_type_size("int"                   SIZEOF_INT)

lzo_check_type_size("long"                  SIZEOF_LONG)

lzo_check_type_size("long long"             SIZEOF_LONG_LONG)

lzo_check_type_size("ptrdiff_t"             SIZEOF_PTRDIFF_T)

lzo_check_type_size("size_t"                SIZEOF_SIZE_T)

lzo_check_type_size("void *"                SIZEOF_VOID_P)

lzo_check_type_size("uintptr_t"             SIZEOF_UINTPTR_T)

lzo_check_type_size("__int16"               SIZEOF___INT16)

lzo_check_type_size("__int32"               SIZEOF___INT32)

lzo_check_type_size("__int64"               SIZEOF___INT64)

lzo_check_type_size("off_t"                 SIZEOF_OFF_T)

##lzo_check_type_size("off64_t"               SIZEOF_OFF64_T)

# Checks for library functions

macro(lzo_check_function_exists func var)

    check_function_exists("${func}" "${var}")

    if(NOT ",${${var}}," STREQUAL ",,")

        add_definitions(-D${var}=1)

    endif()

endmacro()

lzo_check_function_exists(clock_gettime     HAVE_CLOCK_GETTIME)

lzo_check_function_exists(stat              HAVE_STAT)

lzo_check_function_exists(strncasecmp       HAVE_STRNCASECMP)

lzo_check_function_exists(strnicmp          HAVE_STRNICMP)

set(big_endian)

TEST_BIG_ENDIAN(big_endian)

if ("${big_endian}" MATCHES "^1$")

    add_definitions(-DLZO_ABI_BIG_ENDIAN=1)

elseif ("${big_endian}" MATCHES "^0$")

    add_definitions(-DLZO_ABI_LITTLE_ENDIAN=1)

else()

    message(FATAL_ERROR "ERROR: TEST_BIG_ENDIAN failed.")

endif()

#

# "make install"

#

# subdirs relative to CMAKE_INSTALL_PREFIX

if(NOT DEFINED install_doc_subdir)

    set(install_doc_subdir doc)

endif()

if(NOT DEFINED install_include_subdir)

    set(install_include_subdir include)

endif()

if(NOT DEFINED install_lib_subdir)

    set(install_lib_subdir lib)

endif()

if(NOT DEFINED install_examples_subdir)

    set(install_examples_subdir libexec/lzo-examples)

endif()

set(doc_DATA AUTHORS COPYING NEWS THANKS doc/LZO.FAQ doc/LZO.TXT doc/LZOAPI.TXT)

set(pkginclude_HEADERS

    include/lzo/lzo1.h include/lzo/lzo1a.h include/lzo/lzo1b.h

    include/lzo/lzo1c.h include/lzo/lzo1f.h include/lzo/lzo1x.h

    include/lzo/lzo1y.h include/lzo/lzo1z.h include/lzo/lzo2a.h

    include/lzo/lzo_asm.h include/lzo/lzoconf.h include/lzo/lzodefs.h

    include/lzo/lzoutil.h

)

install(FILES ${doc_DATA} DESTINATION ${install_doc_subdir})

install(FILES ${pkginclude_HEADERS} DESTINATION ${install_include_subdir}/lzo)

if(ENABLE_STATIC)

    install(TARGETS lzo_static DESTINATION ${install_lib_subdir})

endif()

if(ENABLE_SHARED)

    install(TARGETS lzo_shared DESTINATION ${install_lib_subdir})

endif()

if(0)

    set(lzo_EXAMPLES lzopack lzotest simple)

    if(NOT ENABLE_STATIC)

        set(d "${CMAKE_INSTALL_PREFIX}/${install_lib_subdir}")

        set_target_properties(${lzo_EXAMPLES} PROPERTIES INSTALL_RPATH "${d}")

    endif()

    install(TARGETS ${lzo_EXAMPLES} DESTINATION ${install_examples_subdir})

endif()

# vim:set ft=cmake ts=4 sw=4 tw=0 et: