jni/libucommon/sources/CMakeLists.txt

# Copyright (C) 2009 David Sugar, Tycho Softworks
#
# This file is free software; as a special exception the author gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# This is a simplified build system for GNU uCommon.  In particular, it
# offers limited cmodel linkage support, at least for mingw32 support (and
# probably visual c 6 also).  If one really needs to do such things outside
# these use cases, it is suggested to continue using the existing autotools
# configure script driven build environment instead.  Mostly the cmake one is
# meant for generating project files for those working with IDE's to do
# otherwise generic builds of the library and supporting applications.

cmake_minimum_required(VERSION 2.6)
PROJECT(ucommon)
set (VERSION 6.0.7)

set(RC_VERSION ${VERSION})
STRING(REGEX REPLACE "[.]" "," RC_VERSION ${RC_VERSION})
set(RC_VERSION "${RC_VERSION},0")

set(SOVERSION ${VERSION})
STRING(REGEX REPLACE "[.].*$" "" SOVERSION ${SOVERSION})

# when we override default install prefix, assume full path is used...

set(INSTALL_INCLUDEDIR include)
set(INSTALL_BINDIR bin)

if(WIN32)
    set(INSTALL_MANDIR man)
    set(INSTALL_DOCDIR doc/${PROJECT_NAME})
    set(INSTALL_LOCALE locale)
    set(INSTALL_LIBDIR bin)
    set(INSTALL_SBINDIR bin)
    set(INSTALL_INFODIR info)
    set(SYSCONFDIR "etc" CACHE PATH "config directory")
    set(STATEDIR "var" CACHE PATH "state directory")
else()
    if (NOT LIB_SUFFIX)
        if (NOT EXISTS /etc/debian_version)
            if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
                set(LIB_SUFFIX 64)
            endif()
        endif()
    endif()
    set(INSTALL_SBINDIR sbin)
    set(INSTALL_MANDIR share/man)
    set(INSTALL_LOCALE share/locale)
    set(INSTALL_DOCDIR share/doc/${PROJECT_NAME})
    set(INSTALL_INFODIR share/info)
    set(INSTALL_LIBDIR lib${LIB_SUFFIX})
    set(SYSCONFDIR "/etc" CACHE PATH "config directory")
    set(STATEDIR "/var" CACHE PATH "state directory")
endif()

set(UCOMMON_LOCALE ${CMAKE_INSTALL_PREFIX}/${INSTALL_LOCALE})
set(UCOMMON_PREFIX ${CMAKE_INSTALL_PREFIX})

set(UCOMMON_CFGPATH ${SYSCONFDIR})
set(UCOMMON_VARPATH ${STATEDIR})

# project options

if(MSVC60)
    set(BUILD_STATIC ON CACHE BOOL "static linking only" FORCE)
    set(BUILD_STDLIB OFF CACHE BOOL "disable C++ stdlib" FORCE)
    set(POSIX_TIMERS OFF CACHE BOOL "does not use posix timers" FORCE)
    set(GCC_ATOMICS OFF CACHE BOOL "does not use gcc atomics" FORCE)
    MARK_AS_ADVANCED(FORCE BUILD_STDLIB BUILD_STATIC POSIX_TIMERS GCC_ATOMICS)
elseif(WIN32)
        option(BUILD_RUNTIME "Set to OFF to build static runtime" ON)
        if(BUILD_RUNTIME)
            set(BUILD_RUNTIME_TYPE SHARED)
        endif()
    option(BUILD_STATIC "Set to OFF to build shared libraries" ON)
    option(BUILD_STDLIB "Set to OFF to disable C++ stdlib" ON)
    set(POSIX_TIMERS OFF CACHE BOOL "does not use posix timers" FORCE)
    set(GCC_ATOMICS OFF CACHE BOOL "does not use gcc atomics" FORCE)
else()
    option(BUILD_STATIC "Set to ON to build static libraries" OFF)
    option(BUILD_STDLIB "Set to OFF to disable C++ stdlib" ON)
    option(POSIX_TIMERS "Set to ON to enable" OFF)
    option(GCC_ATOMICS "Set to ON to enable" OFF)
endif()

MARK_AS_ADVANCED(POSIX_TIMERS GCC_ATOMICS)

option(BUILD_TESTING "Set to ON to build test programs" OFF)

MESSAGE( STATUS "Configuring GNU ${PROJECT_NAME} ${VERSION}...")
include(CheckFunctionExists)
include(CheckLibraryExists)
include(CheckIncludeFiles)
include(CTest)

SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "${PROJECT_NAME} library")
SET(CPACK_PACKAGE_VENDOR              "David Sugar")
SET(CPACK_PACKAGE_DESCRIPTION_FILE    "${CMAKE_CURRENT_SOURCE_DIR}/README")
SET(CPACK_RESOURCE_FILE_LICENSE       "${CMAKE_CURRENT_SOURCE_DIR}/COPYING")
set(PACKAGE_FILE_NAME                 ${PROJECT_NAME})
set(PACKAGE_FILE_VERSION              ${VERSION})

IF (WIN32)
    SET(CPACK_PACKAGE_FILE_NAME "${PACKAGE_FILE_NAME}-${PACKAGE_FILE_VERSION}")
ELSE (WIN32)
    SET(CPACK_PACKAGE_FILE_NAME "${PACKAGE_FILE_NAME}-bin-${PACKAGE_FILE_VERSION}")
    if (NOT CPACK_GENERATOR)
        SET(CPACK_GENERATOR "TBZ2")
    endif()
ENDIF (WIN32)

IF(WIN32 AND NOT UNIX)
    SET(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_FILE_NAME}")

    # There is a bug in NSI that does not handle full unix paths properly. Make
    # sure there is at least one set of four (4) backlasshes.
    # SET(CPACK_PACKAGE_ICON "${CMake_SOURCE_DIR}/Utilities/Release\\\\InstallIcon.bmp")
    # SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\MyExecutable.exe")
    SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} ${PROJECT_NAME}$")
    SET(CPACK_NSIS_HELP_LINK "http:\\\\\\\\www.gnutelephony.org")
    SET(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\www.gnutelephony.org")
    SET(CPACK_NSIS_CONTACT "dyfet@gnutelephony.org")
    SET(CPACK_NSIS_MODIFY_PATH ON)

ENDIF(WIN32 AND NOT UNIX)

set(CPACK_COMPONENTS_ALL libraries headers)
set(CPACK_COMPONENT_LIBRARIES_DISPLAY_NAME "Libraries")
set(CPACK_COMPONENT_HEADERS_DISPLAY_NAME   "C++ Headers")
set(CPACK_COMPONENT_LIBRARIES_DESCRIPTION  "Dynamic library")
set(CPACK_COMPONENT_HEADERS_DESCRIPTION
    "Header files needed to build applications using ucommon library")

# The following components are regex's to match anywhere (unless anchored)
# in absolute path + filename to find files or directories to be excluded
# from source tarball.
SET (CPACK_SOURCE_IGNORE_FILES
#svn, git files
"\\\\.svn/" "\\\\.cvsignore$" "/\\\\.git/"
# temporary files
"\\\\.swp$"
# backup files
"~$"
# eclipse, kdevelop and othe IDE files
"\\\\.cdtproject$" "\\\\.cproject$" "\\\\.project$" "\\\\.settings/" "\\\\.kdev4/" "\\\\.kdev4$"
# others
"\\\\.#" "/#"
# don't copy build and other dirs used for building
"/build/" "/autom4te\\\\.cache/" "/_build/"
# used before
"/CVS/" "/\\\\.libs/" "/\\\\.deps/" "\\\\.o$" "\\\\.lo$" "\\\\.la$" "\\\\.sh$" "Makefile\\\\.in$")

SET(CPACK_SOURCE_GENERATOR "TBZ2")
SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${PACKAGE_FILE_NAME}-${PACKAGE_FILE_VERSION}")

# This must always be last!
INCLUDE(CPack)

# set to true for debug and trace during CMakeLists development
set(CMAKE_VERBOSE_MAKEFILE FALSE)

# add module path of project if it exists...
if (EXISTS "${CMAKE_SOURCE_DIR}/inc/")
    set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/inc/")
endif()

include (inc/ucommon.cmake)

find_package(Threads)
if (CMAKE_HAVE_PTHREAD_H)
    set(HAVE_PTHREAD_H TRUE)
endif()
set (UCOMMON_LIBS ${UCOMMON_LIBS} ${CMAKE_THREAD_LIBS_INIT} ${WITH_LDFLAGS})

if (MINGW OR MSYS)
    set (UCOMMON_LIBS ${UCOMMON_LIBS} mingwex mingw32)
else()
    if (WIN32 AND CMAKE_COMPILER_IS_GNUCXX)
        set (UCOMMON_LIBS ${UCOMMON_LIBS} mingwex mingw32)
    endif()
endif()

if (WIN32 OR MINGW OR MSYS OR CMAKE_SYSTEM MATCHES "Windows")
    set (UCOMMON_LIBS ${UCOMMON_LIBS} crypt32 advapi32 user32 ws2_32 wsock32 kernel32)
endif()

if(UNIX AND NOT BUILD_STDLIB)
    set(UCOMMON_LIBS ${UCOMMON_LIBS} c)
endif()

if(MSYS OR MINGW)
    set(UCOMMON_LIBS ${UCOMMON_LIBS} msvcrt)
endif()

if(CMAKE_COMPILER_IS_GNUCXX AND NOT BUILD_STDLIB)
    check_library_exists(gcc __modsi3 "" HAVE_GCC_LIB)
    if(HAVE_GCC_LIB)
            set(UCOMMON_LIBS ${UCOMMON_LIBS} gcc)
    endif()
endif()


if(UNIX OR MSYS OR MINGW OR CYGWIN)
    check_library_exists(dl dlopen "" HAVE_DL_LIB)
    if (HAVE_DL_LIB)
        set (UCOMMON_LIBS ${UCOMMON_LIBS} dl)
    else()
        check_library_exists(compat dlopen "" HAVE_COMPAT_LIB)
        if(HAVE_COMPAT_LIB)
            set (UCOMMON_LIBS ${UCOMMON_LIBS} compat)
        endif()
    endif()

    check_library_exists(dld shl_load "" HAVE DLD_LIB)
    if (HAVE_DLD_LIB)
        set (UCOMMON_LIBS ${UCOMMON_LIBS} dld)
    endif()

    check_library_exists(socket socket "" HAVE_SOCKET_LIB)
    if (HAVE_SOCKET_LIB)
        set (UCOMMON_LIBS ${UCOMMON_LIBS} socket)
    endif()

    check_library_exists(posix4 sem_wait "" HAVE_POSIX4_LIB)
    if (HAVE_POSIX4_LIB)
        set(UCOMMON_LIBS ${UCOMMON_LIBS} posix4)
    endif()

    check_library_exists(rt clock_gettime "" HAVE_RT_LIB)
    if (HAVE_RT_LIB)
        set(UCOMMON_LIBS ${UCOMMON_LIBS} rt)
    endif()
endif()

set (CMAKE_REQUIRED_LIBRARIES ${UCOMMON_LIBS})
check_function_exists(getaddrinfo HAVE_GETADDRINFO)
check_function_exists(socketpair HAVE_SOCKETPAIR)
check_function_exists(inet_ntop HAVE_INET_NTOP)
check_function_exists(gethostbyname2 HAVE_GETHOSTBYNAME2)
check_function_exists(strcoll HAVE_STRCOLL)
check_function_exists(stricmp HAVE_STRICMP)
check_function_exists(stristr HAVE_STRISTR)
check_function_exists(sysconf HAVE_SYSCONF)
check_function_exists(posix_memalign HAVE_POSIX_MEMALIGN)
check_function_exists(dlopen HAVE_DLOPEN)
check_function_exists(shl_open HAVE_SHL_OPEN)
check_function_exists(pthread_condattr_setclock HAVE_PTHREAD_CONDATTR_SETCLOCK)
check_function_exists(pthread_setconcurrency HAVE_PTHREAD_SETCONCURRENCY)
check_function_exists(pthread_yield HAVE_PTHREAD_YIELD)
check_function_exists(pthread_yield_np HAVE_PTHREAD_YIELD_NP)
check_function_exists(pthread_delay HAVE_PTHREAD_DELAY)
check_function_exists(pthread_delay_np HAVE_PTHREAD_DELAY_NP)
check_function_exists(pthread_setschedprio HAVE_PTHREAD_SETSCHEDPRIO)
check_function_exists(ftok HAVE_FTOK)
check_function_exists(shm_open HAVE_SHM_OPEN)
check_function_exists(localtime_r HAVE_LOCALTIME_R)
check_function_exists(gmtime_r HAVE_GMTIME_R)
check_function_exists(strerror_r HAVE_STRERROR_R)
check_function_exists(nanosleep HAVE_NANOSLEEP)
check_function_exists(clock_nanosleep HAVE_CLOCK_NANOSLEEP)
check_function_exists(clock_gettime HAVE_CLOCK_GETTIME)
check_function_exists(posix_fadvise HAVE_POSIX_FADVISE)
check_function_exists(ftruncate HAVE_FTRUNCATE)
check_function_exists(pwrite HAVE_PWRITE)
check_function_exists(setpgrp HAVE_SETPGRP)
check_function_exists(setlocale HAVE_SETLOCALE)
check_function_exists(gettext HAVE_GETTEXT)
check_function_exists(execvp HAVE_EXECVP)
check_function_exists(atexit HAVE_ATEXIT)
check_function_exists(lstat HAVE_LSTAT)
check_function_exists(realpath HAVE_REALPATH)
check_function_exists(symlink HAVE_SYMLINK)
check_function_exists(readlink HAVE_READLINK)
check_function_exists(waitpid HAVE_WAITPID)
check_function_exists(wait4 HAVE_WAIT4)

check_include_files(sys/stat.h HAVE_SYS_STAT_H)
check_include_files(strings.h HAVE_STRINGS_H)
check_include_files(stdlib.h HAVE_STDLIB_H)
check_include_files(string.h HAVE_STRING_H)
check_include_files(memory.h HAVE_MEMORY_H)
check_include_files(inttypes.h HAVE_INTTYPES_H)
check_include_files(dlfcn.h HAVE_DLFCN_H)
check_include_files(stdint.h HAVE_STDINT_H)
check_include_files(poll.h HAVE_POLL_H)
check_include_files(sys/mman.h HAVE_SYS_MMAN_H)
check_include_files(sys/shm.h HAVE_SYS_SHM_H)
check_include_files(sys/poll.h HAVE_SYS_POLL_H)
check_include_files(sys/timeb.h HAVE_SYS_TIMEB_H)
check_include_files(sys/types.h HAVE_SYS_TYPES_H)
check_include_files(sys/wait.h HAVE_SYS_WAIT_H)
check_include_files(endian.h HAVE_ENDIAN_H)
check_include_files(sys/filio.h HAVE_SYS_FILIO_H)
check_include_files(dirent.h HAVE_DIRENT_H)
check_include_files(unistd.h HAVE_UNISTD_H)
check_include_files(sys/resource.h HAVE_SYS_RESOURCE_H)
check_include_files(wchar.h HAVE_WCHAR_H)
check_include_files(mach/clock.h HAVE_MACH_CLOCK_H)
check_include_files(mach-o/dyld.h HAVE_MACH_O_DYLD_H)
check_include_files(linux/version.h HAVE_LINUX_VERSION_H)
check_include_files(regex.h HAVE_REGEX_H)
check_include_files(sys/inotify.h HAVE_SYS_INOTIFY_H)
check_include_files(sys/event.h HAVE_SYS_EVENT_H)
check_include_files(syslog.h HAVE_SYSLOG_H)
check_include_files(openssl/ssl.h HAVE_OPENSSL)
check_include_files(openssl/fips.h HAVE_OPENSSL_FIPS_H)
check_include_files(libintl.h HAVE_LIBINTL_H)
check_include_files(netinet/in.h HAVE_NETINET_IN_H)
check_include_files(net/if.h HAVE_NET_IF_H)
check_include_files(fcntl.h HAVE_FCNTL_H)
check_include_files(termios.h HAVE_TERMIOS_H)
check_include_files(termio.h HAVE_TERMIO_H)
check_include_files(sys/param.h HAVE_SYS_PARAM_H)
check_include_files(sys/file.h HAVE_SYS_FILE_H)
check_include_files(sys/lockf.h HAVE_SYS_LOCKF_H)
check_include_files(regex.h HAVE_REGEX_H)

if(HAVE_REGEX_H)
    check_library_exists(regex regfree "" HAVE_REGEX_LIB)
    if(HAVE_REGEX_LIB OR MINGW OR MSYS)
        set(UCOMMON_LIBS ${UCOMMON_LIBS} "regex")
    endif()
endif()

set(UCOMMON_LIBS ${UCOMMON_LIBS} ${UCOMMON_LINKING})

# for some reason, normal library searches always fail on broken windows
if (WIN32 AND NOT UNIX AND NOT MINGW AND NOT MSYS)
    set(HAVE_GETADDRINFO True)
    set(HAVE_INET_NTOP True)
endif()

# we can mklink a build framework to top directory of a project...
# this is done because we may have a project specific optimized build of
# common libraries such as openssl...
if(WIN32 AND EXISTS "${CMAKE_BINARY_DIR}/Frameworks/OpenSSL")
    set(OPENSSL_FOUND TRUE)
    if(EXISTS ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/inc32)
        set(OPENSSL_INCLUDE_DIR ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/inc32)
    else()
        set(OPENSSL_INCLUDE_DIR ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/include)
    endif()
    if(NOT BUILD_STATIC AND EXISTS ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/out32dll)
        set(OPENSSL_LIBRARIES ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/out32dll/ssleay32.lib ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/lib/libeay32.lib)
    else()
        set(OPENSSL_LIBRARIES ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/out32dll/ssleay32.lib ${CMAKE_BINARY_DIR}/Frameworks/OpenSSL/lib/libeay32.lib)
    endif()
endif()

# alternate we use generic cmake openssl search...
if(NOT HAVE_OPENSSL AND NOT OPENSSL_FOUND)
    FIND_PACKAGE(OpenSSL)
endif()

# common build options can be passed to cmake using WITH_CFLAGS, WITH_LIBS,
# and WITH_INCLUDES.
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/inc ${WITH_INCLUDES})
add_definitions(${UCOMMON_FLAGS} ${WITH_CFLAGS})
link_libraries(${WITH_LIBS})

# by default we build static libs for windows, shared libs for unix.
# we may also set this from a top level cmake or -DWITH_XX_LIBS

if(BUILD_STATIC)
    set(BUILD_LIBRARY_TYPE STATIC)
else()
    set(BUILD_LIBRARY_TYPE SHARED)
endif()

if(NOT BUILD_RUNTIME_TYPE)
    set(BUILD_RUNTIME_TYPE ${BUILD_LIBRARY_TYPE})
endif()

file(GLOB common_src corelib/*.cpp)
file(GLOB ucommon_inc inc/ucommon/*.h)
file(GLOB commoncpp_src commoncpp/*.cpp)
file(GLOB commoncpp_inc inc/commoncpp/*.h)
file(GLOB ucommon_man utils/*.1)
set(ucommon_man commoncpp-config.1 ucommon-config.1 ${ucommon_man})
list(REMOVE_ITEM ucommon_inc inc/ucommon/secure.h)

if(HAVE_OPENSSL)
    set(secure_inc inc/ucommon/secure.h)
    file(GLOB secure_src openssl/*.cpp openssl/*.h)
    list(APPEND secure_src nossl/common.cpp)
    if(MINGW)
        set(SECURE_LIBS ssl crypto gdi32 z)
    elseif(WIN32 AND NOT CYGWIN)
        set(SECURE_LIBS ssleay32 libeay32 gdi32)
    else()
        set(SECURE_LIBS ssl crypto)
    endif()
elseif(OPENSSL_FOUND)
    file(GLOB secure_src openssl/*.cpp openssl/*.h)
    list(APPEND secure_src nossl/common.cpp)
    include_directories(${OPENSSL_INCLUDE_DIR})
    set(SECURE_LIBS ${OPENSSL_LIBRARIES})
else()
    file(GLOB secure_src nossl/*.cpp nossl/*.h)
endif()

if(NOT WIN32)
    foreach(flag ${UCOMMON_FLAGS})
        set(PACKAGE_FLAGS "${PACKAGE_FLAGS} ${flag}")
    endforeach()
    foreach(lib ${UCOMMON_LIBS})
        STRING(REGEX REPLACE "^[-]l" "" slib ${lib})
        set(PACKAGE_LIBS "${PACKAGE_LIBS} -l${slib}")
    endforeach()
    foreach(lib ${SECURE_LIBS})
        STRING(REGEX REPLACE "^[-]l" "" slib ${lib})
        set(ADDITIONAL_LIBS "${ADDITIONAL_LIBS} -l${slib}")
    endforeach()
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc)
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}-config.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}-config)
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.spec.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.spec @ONLY)

    if(BUILD_STDLIB)
        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/commoncpp.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/commoncpp.pc)
        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/commoncpp-config.cmake ${CMAKE_CURRENT_BINARY_DIR}/commoncpp-config)
    endif()
endif(NOT WIN32)

configure_file(ucommon-config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/ucommon-config.h)
include_directories(${CMAKE_CURRENT_BINARY_DIR})

add_library(ucommon ${BUILD_RUNTIME_TYPE} ${common_src} ${ucommon_inc})
set_target_properties(ucommon PROPERTIES VERSION ${VERSION} SOVERSION ${SOVERSION})
target_link_libraries(ucommon ${UCOMMON_LIBS} ${WITH_LIBS})

add_library(usecure ${BUILD_LIBRARY_TYPE} ${secure_src} ${secure_inc})
set_target_properties(usecure PROPERTIES VERSION ${VERSION} SOVERSION ${SOVERSION})
target_link_libraries(usecure ucommon ${WITH_LIBS} ${SECURE_LIBS} ${UCOMMON_LIBS})
add_dependencies(usecure ucommon)

if(BUILD_STDLIB)
    add_library(commoncpp ${BUILD_LIBRARY_TYPE} ${commoncpp_src} ${commoncpp_inc})
    set_target_properties(commoncpp PROPERTIES VERSION ${VERSION} SOVERSION ${SOVERSION})
    target_link_libraries(commoncpp ucommon ${UCOMMON_LIBS} ${WITH_LIBS} ${SECURE_LIBS})
    add_dependencies(commoncpp ucommon)
endif()

add_executable(ucommon-args utils/args.cpp)
add_dependencies(ucommon-args ucommon)
set_target_properties(ucommon-args PROPERTIES OUTPUT_NAME args)
target_link_libraries(ucommon-args ucommon ${UCOMMON_LIBS} ${WITH_LIBS})

add_executable(usecure-car utils/car.cpp)
add_dependencies(usecure-car usecure ucommon)
set_target_properties(usecure-car PROPERTIES OUTPUT_NAME car)
target_link_libraries(usecure-car usecure ucommon ${SECURE_LIBS} ${UCOMMON_LIBS} ${WITH_LIBS})

add_executable(ucommon-pdetach utils/pdetach.cpp)
add_dependencies(ucommon-pdetach ucommon)
set_target_properties(ucommon-pdetach PROPERTIES OUTPUT_NAME pdetach)
target_link_libraries(ucommon-pdetach ucommon ${UCOMMON_LIBS} ${WITH_LIBS})

add_executable(ucommon-sockaddr utils/sockaddr.cpp)
add_dependencies(ucommon-sockaddr ucommon)
set_target_properties(ucommon-sockaddr PROPERTIES OUTPUT_NAME sockaddr)
target_link_libraries(ucommon-sockaddr ucommon ${UCOMMON_LIBS} ${WITH_LIBS})

add_executable(usecure-scrub utils/scrub.cpp)
add_dependencies(usecure-scrub usecure ucommon)
set_target_properties(usecure-scrub PROPERTIES OUTPUT_NAME scrub-files)
target_link_libraries(usecure-scrub usecure ucommon ${SECURE_LIBS} ${UCOMMON_LIBS} ${WITH_LIBS})

add_executable(usecure-mdsum utils/mdsum.cpp)
add_dependencies(usecure-mdsum usecure ucommon)
set_target_properties(usecure-mdsum PROPERTIES OUTPUT_NAME mdsum)
target_link_libraries(usecure-mdsum usecure ucommon ${SECURE_LIBS} ${UCOMMON_LIBS} ${WITH_LIBS})

add_executable(usecure-zerofill utils/zerofill.cpp)
add_dependencies(usecure-zerofill usecure ucommon)
set_target_properties(usecure-zerofill PROPERTIES OUTPUT_NAME zerofill)
target_link_libraries(usecure-zerofill usecure ucommon ${SECURE_LIBS} ${UCOMMON_LIBS} ${WITH_LIBS})

find_package(Doxygen)

if (DOXYGEN_FOUND)
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/doxy.config.cmake
        ${CMAKE_CURRENT_BINARY_DIR}/doxy.config
        @ONLY )

    seT(DOXY_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/doxy.config")

    #add_custom_target(doc ${DOXYGEN_EXECUTABLE} ${DOXY_CONFIG})
    add_custom_target(doc
                    ${DOXYGEN_EXECUTABLE} ${DOXY_CONFIG}
                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
                    COMMENT "Generating API documentation with Doxygen" VERBATIM
                   )

    #
    # TODO an: taken from internet, to be tested
    #
    # create a windows help .chm file using hhc.exe
    # HTMLHelp DLL must be in path!
    # fallback: use hhw.exe interactively
    IF    (WIN32)
        FIND_PACKAGE(HTMLHelp)
        IF   (HTML_HELP_COMPILER)
            SET (TMP "${CMAKE_CURRENT_BINARY_DIR}\\Doc\\html\\index.hhp")
            STRING(REGEX REPLACE "[/]" "\\\\" HHP_FILE ${TMP} )
            # MESSAGE(SEND_ERROR "DBG  HHP_FILE=${HHP_FILE}")
            ADD_CUSTOM_TARGET(winhelp ${HTML_HELP_COMPILER} ${HHP_FILE})
            ADD_DEPENDENCIES (winhelp doc)

            IF (NOT TARGET_DOC_SKIP_INSTALL)
                # install windows help?
                # determine useful name for output file
                # should be project and version unique to allow installing
                # multiple projects into one global directory
                IF   (EXISTS "${PROJECT_BINARY_DIR}/Doc/html/index.chm")
                    IF   (PROJECT_NAME)
                        SET(OUT "${PROJECT_NAME}")
                    ELSE (PROJECT_NAME)
                        SET(OUT "Documentation") # default
                    ENDIF(PROJECT_NAME)
                    IF   (${PROJECT_NAME}_VERSION_MAJOR)
                        SET(OUT "${OUT}-${${PROJECT_NAME}_VERSION_MAJOR}")
                        IF   (${PROJECT_NAME}_VERSION_MINOR)
                            SET(OUT  "${OUT}.${${PROJECT_NAME}_VERSION_MINOR}")
                            IF   (${PROJECT_NAME}_VERSION_PATCH)
                                SET(OUT "${OUT}.${${PROJECT_NAME}_VERSION_PATCH}")
                            ENDIF(${PROJECT_NAME}_VERSION_PATCH)
                        ENDIF(${PROJECT_NAME}_VERSION_MINOR)
                    ENDIF(${PROJECT_NAME}_VERSION_MAJOR)
                    # keep suffix
                    SET(OUT  "${OUT}.chm")

                    #MESSAGE("DBG ${PROJECT_BINARY_DIR}/Doc/html/index.chm \n${OUT}")
                    # create target used by install and package commands
                    INSTALL(FILES "${PROJECT_BINARY_DIR}/Doc/html/index.chm"
                        DESTINATION ${INSTALL_DOCDIR} RENAME "${OUT}")
                ENDIF(EXISTS "${PROJECT_BINARY_DIR}/Doc/html/index.chm")
            ENDIF(NOT TARGET_DOC_SKIP_INSTALL)

        ENDIF(HTML_HELP_COMPILER)
        # MESSAGE(SEND_ERROR "HTML_HELP_COMPILER=${HTML_HELP_COMPILER}")
    ENDIF (WIN32)
ENDIF(DOXYGEN_FOUND)


message (STATUS)
message (STATUS "-------------------------------------------------------------------------------")
message (STATUS "CMAKE_INSTALL_PREFIX " ${CMAKE_INSTALL_PREFIX} )
message (STATUS "LIB_SUFFIX           " ${LIB_SUFFIX})
message (STATUS "BUILD_STATIC         " ${BUILD_STATIC})
message (STATUS "BUILD STDLIB         " ${BUILD_STDLIB})
message (STATUS "BUILD_TESTING        " ${BUILD_TESTING})
message (STATUS "-------------------------------------------------------------------------------")
message (STATUS)
message (STATUS "Change a value with: cmake -D<Variable>=<Value>")
message (STATUS)

if (BUILD_TESTING)
    ENABLE_TESTING()
    add_subdirectory(test)
endif()

if(NOT WIN32)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION ${INSTALL_LIBDIR}/pkgconfig)
    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/ucommon-config DESTINATION ${INSTALL_BINDIR})
    if(BUILD_STDLIB)
        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/commoncpp-config DESTINATION ${INSTALL_BINDIR})
        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/commoncpp.pc DESTINATION ${INSTALL_LIBDIR}/pkgconfig)
    endif()
endif(NOT WIN32)

install(FILES ${ucommon_inc} ${secure_inc} DESTINATION ${INSTALL_INCLUDEDIR}/ucommon    COMPONENT headers)
install(FILES ${commoncpp_inc} DESTINATION ${INSTALL_INCLUDEDIR}/commoncpp  COMPONENT headers)

if(BUILD_STDLIB)
    install(TARGETS commoncpp DESTINATION ${INSTALL_LIBDIR} COMPONENT libraries)
endif()

install(TARGETS ucommon usecure DESTINATION ${INSTALL_LIBDIR} COMPONENT libraries)
install(TARGETS ucommon-args ucommon-pdetach usecure-car usecure-scrub usecure-mdsum ucommon-sockaddr usecure-zerofill DESTINATION ${INSTALL_BINDIR})
install(FILES ${ucommon_man} DESTINATION ${INSTALL_MANDIR}/man1)

if(CMAKE_GENERATOR MATCHES "Unix Makefiles")
    add_custom_target(uninstall
        WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
        COMMAND xargs <install_manifest.txt
    )
endif()