Newer
Older
include(${CMAKE_CURRENT_LIST_DIR}/CMakeMacroUtils.txt)
set (CHAOS_C_FLAGS "-Wno-deprecated")
set (CHAOS_CXX_FLAGS "-Wno-deprecated")
SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}")
MESG("Setting CC compiler ${CHAOS_CC_COMPILER}")
SET(CMAKE_CXX_COMPILER ${CHAOS_CC_COMPILER})
CheckCompiler("CXX" ${CHAOS_CC_COMPILER})
CheckCompiler("C" ${CHAOS_C_COMPILER})
SET(CHAOS_BOOST_FLAGS toolset=${CHAOS_C_COMPILER})
Andrea Michelotti
committed
IF(CERN_ROOT)
ADD_DEFINITIONS(-DCERN_ROOT)
ENDIF()
IF(NOT DEFINED PROCESSOR_COUNT)
SET(PROCESSOR_COUNT 4)
execute_process(COMMAND getconf _NPROCESSORS_ONLN
OUTPUT_VARIABLE PROCESSOR_COUNT
)
STRING(REPLACE "\n" "" PROCESSOR_COUNT ${PROCESSOR_COUNT})
option(CHAOS_FORCE32 "Set to ON to enable 32 bit compilation" OFF)
option(CHAOS_STATIC "Set static compilation" OFF)
option(ENABLE_MEMCACHE "Enable Memcacahe" OFF)
option(CHAOS_ENABLE_C11 "Enable C11" ON)
option(CHAOS_DISABLE_EVENTFD "Disable EventFD" OFF)
option(CHAOS_BUILD_CACHE "Keep third part sources" ON)
option(CHAOS_BOOST_VERSION "Use a predefined boost version" 66)
option(CHAOS_BOOST_MINOR_VERSION "Use a predefined boost minor version" 0)
option(CHAOS_BOOST_DYNAMIC "compile and use dynamic boost" OFF)
option(CHAOS_BUILD_UNITSERVER "Automatically build an Unit Server that includes all CUs found in distribution" ON)
Andrea Michelotti
committed
option(CHAOS_SANITIZER "sanitize the specified project" "")
option(CHAOS_ADDRESS_SANITIZER "sanitize address" OFF)
option(CHAOS_THREAD_SANITIZER "sanitize threads" OFF)
option(CHAOS_DRIVER_MISC "Driver Misc" ON)
option(CHAOS_DRIVER_CCALT "Driver CCALT" ON)
option(CHAOS_DRIVER_LUMINOMETER "Driver Luminometer" OFF)
option(CHAOS_ENABLE_ZMQ_MONITOR "Enable ZMQ Monitor" OFF)
option(CHAOS_EPICS_SUPPORT "Enable EPICS SUPPORT/DRIVERS" OFF)
option(CHAOS_TEST "Enable Test" OFF)
option(GPUFIT "Fast Fitting libraries (needs CUDA toolkit)" OFF)
Andrea Michelotti
committed
IF(CHAOS_EPICS_SUPPORT)
add_definitions(-DEPICS)
INCLUDE_DIRECTORIES(${CMAKE_INSTALL_PREFIX}/include/compiler/gcc ${CMAKE_INSTALL_PREFIX}/include/os/Linux )
LINK_DIRECTORIES(${CMAKE_INSTALL_PREFIX}/lib/linux-x86_64)
IF(NOT CHAOS_VERSION_MAJOR)
SET(CHAOS_VERSION_MAJOR "1")
ENDIF()
IF(NOT CHAOS_VERSION_MINOR)
SET(CHAOS_VERSION_MINOR "1")
ENDIF()
IF(NOT CHAOS_BUILD_ID)
SET(CHAOS_BUILD_ID 666)
ENDIF()
IF(CHAOS_ENABLE_ZMQ_MONITOR)
ADD_DEFINITIONS(-DENABLE_ZMQ_MONITOR)
ENDIF()
ADD_DEFINITIONS(-DCSLIB_VERSION_MAJOR="${CHAOS_VERSION_MAJOR}")
ADD_DEFINITIONS(-DCSLIB_VERSION_MINOR="${CHAOS_VERSION_MINOR}")
ADD_DEFINITIONS(-DCSLIB_BUILD_ID=${CHAOS_BUILD_ID})
SET(GCC_COVERAGE_COMPILE_FLAGS "-O0 -g -fprofile-arcs -ftest-coverage")
# SET(GCC_COVERAGE_LINK_FLAGS "-lgcov")
SET(GCC_COVERAGE_LINK_LIB "gcov")
SET(GCC_COVERAGE_LINK_FLAGS "-fprofile-arcs -ftest-coverage -coverage")
# ADD_DEFINITIONS(${GCC_COVERAGE_COMPILE_FLAGS})
SET(CHAOS_LINKER_FLAGS "${CHAOS_LINKER_FLAGS} ${GCC_COVERAGE_LINK_FLAGS}")
Andrea Michelotti
committed
if((CMAKE_BUILD_TYPE MATCHES DEBUG) OR (CMAKE_BUILD_TYPE MATCHES Debug))
Andrea Michelotti
committed
if((CMAKE_BUILD_TYPE MATCHES Release) OR (CMAKE_BUILD_TYPE MATCHES RELEASE))
MESG("ENABLING RELEASE on ${PROJECT_NAME}")
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -O3")
set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -O3")
ENDIF()
if((CMAKE_BUILD_TYPE MATCHES RelWithDebInfo) OR (CMAKE_BUILD_TYPE MATCHES RELWITHDEBINFO))
MESG("ENABLING RELWITHDEBINFO on ${PROJECT_NAME}")
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -g -O3")
set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -g -O3")
ENDIF()
if((CMAKE_BUILD_TYPE MATCHES MinSizeRel) OR (CMAKE_BUILD_TYPE MATCHES MINSIZEREL))
MESG("ENABLING MINSIZEREL on ${PROJECT_NAME}")
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -Os")
set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -Os")
ENDIF()
if (CHAOS_DEBUG)
MESG("Enable debug mode")
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DDEBUG -g")
set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -DDEBUG -g")
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -fsanitize=address")
set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -fsanitize=address")
ENDIF()
if (CHAOS_THREAD_SANITIZER)
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -fsanitize=thread")
set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -fsanitize=thread")
ENDIF()
set (BOOST_CXX_ADDITIONAL_FLAGS "")
IF(CHAOS_ENABLE_C11 AND NOT CHAOS_TARGET)
# set (BOOST_CXX_ADDITIONAL_FLAGS "-fvisibility=default")
ELSE()
# set (BOOST_CXX_ADDITIONAL_FLAGS "-fvisibility=default")
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -std=c++98 -DFORCE_BOOST_SHPOINTER")
ENDIF()
IF( ( DEFINED ENV{CHAOS32}) OR CHAOS_FORCE_32 )
MESG("Enabling 32 bit Compilation")
set (BUILD_FORCE_32 1)
set (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -m32")
set (CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -m32")
SET( CHAOS_BOOST_FLAGS "${CHAOS_BOOST_FLAGS} cflags=-m32 cxxflags=-m32 address-model=32")
set (CMAKE_LINK_FLAGS "-m32")
ENDIF()
IF(CHAOS_BUILD_CACHE)
MESG("activated chaos build cache ${CACHE_DIR}")
if(NOT EXISTS "${CACHE_DIR}")
FILE(MAKE_DIRECTORY ${CACHE_DIR})
ENDIF()
EXECUTE_PROCESS(COMMAND uname -s OUTPUT_VARIABLE CHAOS_SYSTEM_NAME)
EXECUTE_PROCESS(COMMAND uname -m OUTPUT_VARIABLE CHAOS_SYSTEM_MACHINE)
STRING(REPLACE "\n" "" CHAOS_SYSTEM_NAME ${CHAOS_SYSTEM_NAME})
STRING(REPLACE "\n" "" CHAOS_SYSTEM_MACHINE ${CHAOS_SYSTEM_MACHINE})
Claudio Bisegni
committed
SET(SYSTEM_NAME ${CHAOS_SYSTEM_NAME})
SET(CMAKE_SYSTEM_NAME ${CHAOS_SYSTEM_NAME})
Claudio Bisegni
committed
IF (DEFINED ENV{CHAOS_TARGET} AND NOT CHAOS_TARGET)
SET(CHAOS_TARGET $ENV{CHAOS_TARGET})
ENDIF()
IF(CHAOS_TARGET)
SET(CHAOS_POSTFIX ${CHAOS_TARGET})
ADD_DEFINITIONS(-DCHAOS_TARGET)
ELSE()
SET(CHAOS_POSTFIX "${CHAOS_SYSTEM_MACHINE}-${CHAOS_SYSTEM_NAME}")
ENDIF()
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_STATIC_RUNTIME ON)
IF(${SYSTEM_NAME} MATCHES "Darwin")
# Mac OS X specific code
MESG("enabling MAC compilation")
SET(FrameworkLib boost_program_options boost_date_time boost_system boost_chrono boost_regex boost_log_setup boost_log boost_filesystem boost_thread boost_atomic boost_random jsoncpp pthread dl ${GCC_COVERAGE_LINK_LIB})
SET(CHAOS_BOOST_FLAGS toolset=clang)
CheckCompiler("CXX" clang++)
CheckCompiler("C" clang)
SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -stdlib=libc++")
set(CHAOS_LINKER_FLAGS "${CHAOS_LINKER_FLAGS} -stdlib=libc++")
SET(FrameworkLib boost_program_options boost_date_time boost_system boost_chrono boost_regex boost_log_setup boost_log boost_filesystem boost_thread boost_atomic boost_random jsoncpp pthread rt dl ${GCC_COVERAGE_LINK_LIB})
IF ( NOT CMAKE_INSTALL_PREFIX AND DEFINED ENV{CHAOS_PREFIX} )
set(CMAKE_INSTALL_PREFIX $ENV{CHAOS_PREFIX} CACHE FILEPATH "path")
set(CMAKE_INSTALL_PREFIX $ENV{CHAOS_PREFIX})
MESG("Setting Install Dir to CHAOS_PREFIX ${CMAKE_INSTALL_PREFIX}")
ELSE()
IF(NOT DEFINED CMAKE_INSTALL_PREFIX)
set(CMAKE_INSTALL_PREFIX ${CHAOS_FRAMEWORK}/chaos-distrib-${CHAOS_POSTFIX} CACHE FILEPATH "path")
set(CMAKE_INSTALL_PREFIX ${CHAOS_FRAMEWORK}/chaos-distrib-${CHAOS_POSTFIX})
MESG("Overriding default CHAOS_PREFIX to ${CMAKE_INSTALL_PREFIX}")
Claudio Bisegni
committed
IF(${CHAOS_TARGET} MATCHES "armhf")
MESG("checking armhf cross compilation chain....")
CheckCompiler("CXX" arm-linux-gnueabihf-g++-4.8)
CheckCompiler("C" arm-linux-gnueabihf-gcc-4.8)
SET(CMAKE_SYSTEM_NAME "Linux")
SET(CMAKE_SYSTEM_PROCESSOR "arm")
# SET(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabihf/)
# SET(CMAKE_CXX_COMPILER_WORKS OFF)
# unset(CMAKE_CXX_COMPILER_WORKS CACHE)
# unset(CMAKE_CXX_COMPILER_WORKS)
SET(COMP_FLAGS "-D__BSON_USEMEMCPY__ -mcpu=xscale -D__BSON_USEM")
SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DBOOST_ASIO_DISABLE_EVENTFD -D__BSON_USEMEMCPY__ -D__BSON_USEMEMCPY__ -DBOOST_ASIO_DISABLE_EVENTFD -mno-unaligned-access -DDISABLE_COMPARE_AND_SWAP")
SET(CHAOS_CROSS_HOST arm-linux-gnueabihf)
ELSE()
IF(${CHAOS_TARGET} MATCHES "arm-linux-2.6")
MESG("Cross compiling for ARM(soft float) platforms on linux 2.6")
CheckCompiler("CXX" arm-infn-linux-gnueabi-g++)
CheckCompiler("C" arm-infn-linux-gnueabi-gcc)
SET(CHAOS_CROSS_HOST arm-infn-linux-gnueabi)
SET(CHAOS_ENABLE_C11 "Enable C11" OFF)
SET (CHAOS_C_FLAGS "${CHAOS_C_FLAGS} -fno-builtin -DCHAOS_NO_BACKTRACE -DBOOST_ASIO_DISABLE_EVENTFD -D__BSON_USEMEMCPY__ -mcpu=xscale -D__BSON_USEMEMCPY__ -DBOOST_ASIO_DISABLE_EVENTFD -mno-unaligned-access -DDISABLE_COMPARE_AND_SWAP -mfloat-abi=soft")
SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} ${CHAOS_C_FLAGS}")
SET(CHAOS_BOOST_FLAGS toolset=gcc-arm target-os=linux)
SET(CHAOS_DISABLE_EVENTFD ON)
set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic
set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS)
MESG("Cross compiling for i686 platforms on linux 2.6")
CheckCompiler("CXX" i686-nptl-linux-gnu-g++)
CheckCompiler("C" i686-nptl-linux-gnu-gcc)
SET(CHAOS_CROSS_HOST i686-nptl-linux-gnu)
SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DCHAOS_NO_BACKTRACE -DBOOST_ASIO_DISABLE_EVENTFD")
SET(CHAOS_BOOST_FLAGS target-os=linux)
SET(CHAOS_DISABLE_EVENTFD ON)
set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic
set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS)
ELSE()
IF(${CHAOS_TARGET} MATCHES "crio90xx")
MESG("Cross compiling for crio90xx")
CheckCompiler("CXX" arm-nilrt-linux-gnueabi-g++)
CheckCompiler("C" arm-nilrt-linux-gnueabi-gcc)
SET(CHAOS_DISABLE_EVENTFD ON)
SET(CHAOS_LINKER_FLAGS "${CHAOS_LINKER_FLAGS} -L/usr/local/chaos/oecore-x86_64/sysroots/armv7a-vfp-neon-nilrt-linux-gnueabi/lib")
SET(CHAOS_CROSS_HOST arm-nilrt-linux-gnueabi)
SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -march=armv7-a -mthumb-interwork -mfloat-abi=softfp -mfpu=neon -mno-unaligned-access --sysroot=/usr/local/chaos/oecore-x86_64/sysroots/armv7a-vfp-neon-nilrt-linux-gnueabi -L/usr/local/chaos/oecore-x86_64/sysroots/armv7a-vfp-neon-nilrt-linux-gnueabi/lib -DBOOST_ASIO_DISABLE_EVENTFD")
SET(CHAOS_BOOST_FLAGS target-os=linux)
ELSE()
ERROR("UNSUPPORTED CHAOS_TARGET ${CHAOS_TARGET}")
ENDIF()
ENDIF()
IF(NOT CMAKE_CXX_COMPILER)
ERROR("CANNOT FOUND COMPILER FOR ${CHAOS_TARGET}, \"${CHAOS_CROSS_HOST}-g++\" should be found in path")
ENDIF()
ENDIF()
IF(NOT CMAKE_CXX_COMPILER)
project(config)
ENDIF()
if(CHAOS_BOOST_DYNAMIC)
SET(CHAOS_CXX_FLAGS "${CHAOS_CXX_FLAGS} -DBOOST_LOG_DYN_LINK")
SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} link=shared runtime-link=shared)
ELSE()
SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} link=static runtime-link=static)
ENDIF()
IF(CHAOS_LINKER_FLAGS)
SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} linkflags=\""${CHAOS_LINKER_FLAGS}"\")
ENDIF()
# SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} cxxflags=\""${CHAOS_CXX_FLAGS} -fPIC ${BOOST_CXX_ADDITIONAL_FLAGS}"\" --prefix=${CMAKE_INSTALL_PREFIX} --with-program_options --with-exception --with-chrono --with-filesystem --with-log --with-regex --with-random --with-system --with-thread --with-atomic --with-timer install "-j ${PROCESSOR_COUNT}" )
SET(CHAOS_BOOST_FLAGS ${CHAOS_BOOST_FLAGS} cxxflags=\""-fPIC"\" --variant=release --prefix=${CMAKE_INSTALL_PREFIX} --with-program_options --with-iostreams --with-exception --with-chrono --with-filesystem --with-log --with-regex --with-random --with-system --with-thread --with-atomic --with-timer install "-j ${PROCESSOR_COUNT}" )
IF(CHAOS_STATIC)
MESG("Enabling Static compilation")
SET(BUILD_FORCE_STATIC 1)
SET(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
ADD_DEFINITIONS(-DCHAOS_STATIC)
SET(CHAOS_LINKER_FLAGS "-static")
SET(CMAKE_EXE_LINKER_FLAGS "-static")
SET(BUILD_SHARED_LIBRARIES OFF)
SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS)
SET(CMAKE_SHARED_LIBRARY_LINK_CC_FLAGS)
set(CMAKE_EXE_LINK_DYNAMIC_C_FLAGS) # remove -Wl,-Bdynamic
set(CMAKE_EXE_LINK_DYNAMIC_CXX_FLAGS)
# SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES LINK_SEARCH_END_STATIC 1)
set (CMAKE_C_FLAGS ${CHAOS_C_FLAGS} CACHE STRING "C flags")
set (CMAKE_CXX_FLAGS ${CHAOS_CXX_FLAGS} CACHE STRING "C++ flags")
set (CMAKE_EXE_LINKER_FLAGS ${CHAOS_LINKER_FLAGS} CACHE STRING "Linker flags")
set (CMAKE_C_FLAGS ${CHAOS_C_FLAGS})
set (CMAKE_CXX_FLAGS ${CHAOS_CXX_FLAGS})
set (CMAKE_EXE_LINKER_FLAGS ${CHAOS_LINKER_FLAGS})
# ADD_DEFINITIONS(${CHAOS_C_FLAGS} ${CHAOS_CXX_FLAGS})
IF(CHAOS_CROSS_HOST)
SET( CROSS_HOST "--host=${CHAOS_CROSS_HOST}")
ENDIF()
SET(EXTERNAL_BUILD_DIR ${CMAKE_CURRENT_LIST_DIR}/../external-${CHAOS_POSTFIX})
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build-${CHAOS_POSTFIX})
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build-${CHAOS_POSTFIX})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/build-${CHAOS_POSTFIX})
get_filename_component(CHAOS_CXX_COMPILER_REL ${CMAKE_CXX_COMPILER} NAME)
get_filename_component(CHAOS_C_COMPILER_REL ${CMAKE_C_COMPILER} NAME)
######
#### TOOL VERSIONS
if (CHAOS_BOOST_MINOR_VERSION)
SET(BOOST_MINOR_VERSION ${CHAOS_BOOST_MINOR_VERSION})
ELSE()
SET(BOOST_MINOR_VERSION 0)
ENDIF()
if( CHAOS_BOOST_VERSION)
SET(BOOST_VERSION ${CHAOS_BOOST_VERSION})
INCLUDE_DIRECTORIES(${CHAOS_FRAMEWORK})
# if( DEFINED ENV{CHAOS_BUNDLE} )
# MESSAGE(STATUS "Using Chaos Bundle Dir $ENV{CHAOS_BUNDLE}")
# set (PROJECT_SOURCE_DIR $ENV{CHAOS_BUNDLE})
# INCLUDE_DIRECTORIES($ENV{CHAOS_BUNDLE}/chaosframework)
# ENDIF()
#If(CHAOS_C_COMPILER)
# MESG("Setting C compiler ${CHAOS_C_COMPILER}")
# SET(CMAKE_C_COMPILER ${CHAOS_C_COMPILER})
#ENDIF()
#set(FrameworkLib $ENV{CHAOS_LINK_LIBRARY})
#separate_arguments(FrameworkLib)
INCLUDE_DIRECTORIES(. ${PROJECT_SOURCE_DIR} ${CMAKE_INSTALL_PREFIX}/include)
LINK_DIRECTORIES(${CMAKE_LIBRARY_OUTPUT_DIRECTORY} ${CMAKE_INSTALL_PREFIX}/lib ${CMAKE_INSTALL_PREFIX}/lib64)
# foreach(cu ${CHAOS_CUS})
# string (REPLACE ".cpp" ".h" cuh ${cu})
# MESG("CU defined ${cu}")
# IF (DEFINED CU_H)
# SET(CU_H ${CU_H} ${cuh})
# ELSE()
# SET(CU_H ${cuh})
# ENDIF()
# IF (DEFINED CU_H)
# INSTALL(FILES ${CU_H} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/${PROJECT_OUT_H})
# ENDIF()
# ENDFOREACH()
IF (DEFINED PROJECT_NAME)
FILE(GLOB conf_src conf/*)
FILE(GLOB perf_src perf/*)
INSTALL(FILES ${conf_src} ${perf_src} DESTINATION etc/${PROJECT_NAME})
ENDIF()
# SET(CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX} CACHE FILEPATH "prefix")
# SET(CMAKE_LIBRARY_PATH ${CMAKE_INSTALL_PREFIX}/lib CACHE FILEPATH "prefix")
# SET(CMAKE_FRAMEWORK_PATH ${CMAKE_LIBRARY_PATH} CACHE FILEPATH "prefix")
SET(CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX} )
SET(CMAKE_LIBRARY_PATH ${CMAKE_INSTALL_PREFIX}/lib)
SET(CMAKE_FRAMEWORK_PATH ${CMAKE_LIBRARY_PATH})
MESG("Chaos Generic settings dir ${CMAKE_CURRENT_SOURCE_DIR} CHAOS_FRAMEWORK: ${CHAOS_FRAMEWORK} on ${PROJECT_NAME}")
MESG("Host System : ${CHAOS_SYSTEM_NAME}-${CHAOS_SYSTEM_MACHINE}")
MESG("Installation Dir : ${CMAKE_INSTALL_PREFIX}")
MESG("CXX compiler : ${CMAKE_CXX_COMPILER}")
MESG("CXX Flags : ${CHAOS_CXX_FLAGS}")
MESG("C compiler : ${CMAKE_C_COMPILER}")
MESG("C Flags : ${CHAOS_C_FLAGS}")
MESG("Linker Flags : ${CHAOS_LINKER_FLAGS}")
MESG("Parallel build : ${PROCESSOR_COUNT}")
MESG("Framework libs : ${FrameworkLib}")
if(NOT EXISTS "${CMAKE_INSTALL_PREFIX}")
FILE(MAKE_DIRECTORY ${CMAKE_INSTALL_PREFIX})
ENDIF()
FILE(COPY ${CMAKE_CURRENT_LIST_DIR}/Findchaos.cmake DESTINATION ${CMAKE_INSTALL_PREFIX}/)
FILE(COPY ${CMAKE_CURRENT_LIST_DIR}/CMakeMacroUtils.txt DESTINATION ${CMAKE_INSTALL_PREFIX}/)
unset(Boost_FOUND CACHE)
#find_package( Boost COMPONENTS program_options regex date_time system chrono regex log_setup log filesystem thread atomic)
unset(LIB_NEED CACHE)
find_library(LIB_NEED NAMES boost_program_options boost_regex boost_date_time boost_system boost_chrono boost_log_setup boost_log boost_filesystem boost_thread boost_atomic boost_random PATHS ${CMAKE_INSTALL_PREFIX}/lib NO_DEFAULT_PATH)
if(LIB_NEED)
MESG("BOOST found !!")
# include_directories(${Boost_INCLUDE_DIRS})
else()
MESG("boost not found in ${CMAKE_INSTALL_PREFIX}/lib downloading...")
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_STATIC_RUNTIME ON)
# boostInstall(${BOOST_VERSION} ${BOOST_MINOR_VERSION} https://dl.bintray.com/boostorg/release/1.${BOOST_VERSION}.${BOOST_MINOR_VERSION}/source "${CHAOS_BOOST_FLAGS}")
boostInstall(${BOOST_VERSION} ${BOOST_MINOR_VERSION} https://sourceforge.net/projects/boost/files/boost/1.${BOOST_VERSION}.${BOOST_MINOR_VERSION} "${CHAOS_BOOST_FLAGS}")