472 lines
15 KiB
CMake
472 lines
15 KiB
CMake
cmake_minimum_required(VERSION 3.5)
|
|
|
|
project(biboumi)
|
|
|
|
set(${PROJECT_NAME}_VERSION_MAJOR 10)
|
|
set(${PROJECT_NAME}_VERSION_MINOR 0)
|
|
set(${PROJECT_NAME}_VERSION_SUFFIX "~dev")
|
|
|
|
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
|
|
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11.2)
|
|
message(FATAL_ERROR "GCC version must be at least 11.2.")
|
|
endif()
|
|
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
|
|
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14)
|
|
message(FATAL_ERROR "Clang version must be at least 14.")
|
|
endif()
|
|
endif()
|
|
|
|
if(NOT CMAKE_BUILD_TYPE)
|
|
set(CMAKE_BUILD_TYPE "Debug" CACHE STRING
|
|
"Build type (Release/Debug/RelWithDebInfo/MinSizeRel)" FORCE)
|
|
endif()
|
|
|
|
#
|
|
## Find optional instrumentation libraries that will be used in debug only
|
|
#
|
|
find_library(LIBASAN NAMES asan libasan.so.8 libasan.so.4 libasan.so.3 libasan.so.2 libasan.so.1)
|
|
find_library(LIBUBSAN NAMES ubsan libubsan.so.0)
|
|
|
|
#
|
|
## Set various debug flags (instrumentation libs, coverage, …)
|
|
#
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++20 -pedantic -Wall -Wextra -Wconversion -fvisibility=hidden -fvisibility-inlines-hidden")
|
|
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fprofile-arcs -ftest-coverage --coverage")
|
|
endif()
|
|
if(LIBASAN)
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
|
|
endif()
|
|
if(LIBUBSAN)
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=undefined")
|
|
endif()
|
|
|
|
#
|
|
## Set the software version, archive name, RPM name etc
|
|
#
|
|
set(ARCHIVE_NAME ${CMAKE_PROJECT_NAME}-${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR})
|
|
set(RPM_VERSION ${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR})
|
|
|
|
if(${PROJECT_NAME}_VERSION_SUFFIX MATCHES ".+")
|
|
set(ARCHIVE_NAME ${ARCHIVE_NAME}${${PROJECT_NAME}_VERSION_SUFFIX})
|
|
set(RPM_VERSION ${RPM_VERSION}${${PROJECT_NAME}_VERSION_SUFFIX})
|
|
endif()
|
|
|
|
if(${PROJECT_NAME}_VERSION_SUFFIX MATCHES "^~dev$")
|
|
# If we are on a dev version, append the hash of the current git HEAD to
|
|
# the version
|
|
include(FindGit)
|
|
if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
|
|
execute_process(COMMAND git --git-dir=${CMAKE_SOURCE_DIR}/.git rev-parse --short HEAD
|
|
OUTPUT_VARIABLE GIT_REVISION
|
|
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
|
if(GIT_REVISION)
|
|
set(${PROJECT_NAME}_VERSION_SUFFIX "${${PROJECT_NAME}_VERSION_SUFFIX} (${GIT_REVISION})")
|
|
set(ARCHIVE_NAME ${ARCHIVE_NAME}${GIT_REVISION})
|
|
set(RPM_VERSION ${RPM_VERSION}${GIT_REVISION})
|
|
endif()
|
|
endif()
|
|
endif()
|
|
|
|
set(SOFTWARE_VERSION
|
|
${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR}${${PROJECT_NAME}_VERSION_SUFFIX})
|
|
|
|
#
|
|
## The rule that generates the documentation
|
|
#
|
|
add_custom_target(html COMMAND make html BUILDDIR=${CMAKE_CURRENT_BINARY_DIR}
|
|
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc)
|
|
add_custom_target(man COMMAND make man BUILDDIR=${CMAKE_CURRENT_BINARY_DIR}
|
|
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc)
|
|
add_custom_target(doc DEPENDS html man)
|
|
|
|
#
|
|
## Set this search path for cmake, to find our custom search modules
|
|
#
|
|
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
|
|
find_package(ICONV REQUIRED)
|
|
find_package(LIBUUID REQUIRED)
|
|
find_package(EXPAT REQUIRED)
|
|
|
|
#
|
|
## Find all the libraries (optional or not)
|
|
#
|
|
if(WITH_LIBIDN)
|
|
find_package(LIBIDN REQUIRED)
|
|
elseif(NOT WITHOUT_LIBIDN)
|
|
find_package(LIBIDN)
|
|
endif()
|
|
|
|
if(WITH_SYSTEMD)
|
|
find_package(SYSTEMD REQUIRED)
|
|
elseif(NOT WITHOUT_SYSTEMD)
|
|
find_package(SYSTEMD)
|
|
endif()
|
|
|
|
if(WITH_BOTAN)
|
|
find_package(BOTAN REQUIRED)
|
|
elseif(NOT WITHOUT_BOTAN)
|
|
find_package(BOTAN)
|
|
endif()
|
|
|
|
if(NOT BOTAN_FOUND)
|
|
find_package(GCRYPT REQUIRED)
|
|
endif()
|
|
|
|
if(WITH_UDNS)
|
|
find_package(UDNS REQUIRED)
|
|
elseif(NOT WITHOUT_UDNS)
|
|
find_package(UDNS)
|
|
endif()
|
|
|
|
if(WITH_SQLITE3)
|
|
find_package(SQLITE3 REQUIRED)
|
|
elseif(NOT WITHOUT_SQLITE3)
|
|
find_package(SQLITE3)
|
|
endif()
|
|
|
|
if(WITH_POSTGRESQL)
|
|
find_package(PQ REQUIRED)
|
|
elseif(NOT WITHOUT_POSTGRESQL)
|
|
find_package(PQ)
|
|
endif()
|
|
|
|
if(WITH_CURL)
|
|
find_package(CURL REQUIRED)
|
|
elseif(NOT WITHOUT_CURL)
|
|
find_package(CURL)
|
|
endif()
|
|
|
|
#
|
|
## Set all the include directories, depending on what libraries are used
|
|
#
|
|
include_directories(${EXPAT_INCLUDE_DIRS})
|
|
include_directories(${ICONV_INCLUDE_DIRS})
|
|
include_directories(${LIBUUID_INCLUDE_DIRS})
|
|
if(SYSTEMD_FOUND)
|
|
include_directories(${SYSTEMD_INCLUDE_DIRS})
|
|
endif()
|
|
if(BOTAN_FOUND)
|
|
include_directories(SYSTEM ${BOTAN_INCLUDE_DIRS})
|
|
endif()
|
|
if(UDNS_FOUND)
|
|
include_directories(${UDNS_INCLUDE_DIRS})
|
|
endif()
|
|
if(CURL_FOUND)
|
|
include_directories(${CURL_INCLUDE_DIRS})
|
|
endif()
|
|
|
|
# To be able to include the config.h and other files generated by cmake
|
|
include_directories("${CMAKE_CURRENT_BINARY_DIR}/src/")
|
|
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/")
|
|
include_directories("${CMAKE_CURRENT_BINARY_DIR}/")
|
|
|
|
#
|
|
## Define all the modules
|
|
#
|
|
|
|
file(GLOB source_utils
|
|
src/utils/*.[hc]pp)
|
|
add_library(utils OBJECT ${source_utils})
|
|
|
|
file(GLOB source_irc
|
|
src/irc/*.[hc]pp)
|
|
add_library(irc OBJECT ${source_irc})
|
|
|
|
file(GLOB source_xmpp
|
|
src/xmpp/*.[hc]pp)
|
|
add_library(xmpp OBJECT ${source_xmpp})
|
|
|
|
file(GLOB source_identd
|
|
src/identd/*.[hc]pp)
|
|
add_library(identd OBJECT ${source_identd})
|
|
|
|
file(GLOB source_bridge
|
|
src/bridge/*.[hc]pp)
|
|
add_library(bridge OBJECT ${source_bridge})
|
|
|
|
file(GLOB source_scheduler
|
|
src/scheduler/*.[hc]pp)
|
|
add_library(scheduler OBJECT ${source_scheduler})
|
|
|
|
file(GLOB source_config
|
|
src/config/*.[hc]pp)
|
|
add_library(config OBJECT ${source_config})
|
|
|
|
file(GLOB source_logger
|
|
src/logger/*.[hc]pp)
|
|
add_library(logger OBJECT ${source_logger})
|
|
|
|
file(GLOB source_network
|
|
src/network/*.[hc]pp)
|
|
add_library(network OBJECT ${source_network})
|
|
|
|
option(DEBUG_SQL_QUERIES
|
|
"If set to true, every SQL statement executed will be logged and timed"
|
|
OFF)
|
|
if(SQLITE3_FOUND OR PQ_FOUND)
|
|
file(GLOB source_database
|
|
src/database/*.[hc]pp)
|
|
add_library(database OBJECT ${source_database})
|
|
|
|
if(SQLITE3_FOUND)
|
|
include_directories(database ${SQLITE3_INCLUDE_DIRS})
|
|
endif()
|
|
if(PQ_FOUND)
|
|
include_directories(database ${PQ_INCLUDE_DIRS})
|
|
endif()
|
|
set(USE_DATABASE TRUE)
|
|
endif()
|
|
|
|
#
|
|
## Define the executables
|
|
#
|
|
|
|
## main
|
|
add_executable(${PROJECT_NAME} src/main.cpp
|
|
$<TARGET_OBJECTS:utils>
|
|
$<TARGET_OBJECTS:config>
|
|
$<TARGET_OBJECTS:logger>
|
|
$<TARGET_OBJECTS:network>
|
|
$<TARGET_OBJECTS:xmpp>
|
|
$<TARGET_OBJECTS:bridge>
|
|
$<TARGET_OBJECTS:scheduler>
|
|
$<TARGET_OBJECTS:irc>
|
|
$<TARGET_OBJECTS:identd>)
|
|
|
|
## test_suite
|
|
file(GLOB source_tests
|
|
tests/*.cpp)
|
|
add_executable(test_suite ${source_tests}
|
|
$<TARGET_OBJECTS:utils>
|
|
$<TARGET_OBJECTS:config>
|
|
$<TARGET_OBJECTS:logger>
|
|
$<TARGET_OBJECTS:network>
|
|
$<TARGET_OBJECTS:xmpp>
|
|
$<TARGET_OBJECTS:bridge>
|
|
$<TARGET_OBJECTS:scheduler>
|
|
$<TARGET_OBJECTS:irc>
|
|
$<TARGET_OBJECTS:identd>)
|
|
set_target_properties(test_suite PROPERTIES EXCLUDE_FROM_ALL TRUE)
|
|
if(USE_DATABASE)
|
|
target_sources(${PROJECT_NAME} PRIVATE $<TARGET_OBJECTS:database>)
|
|
target_sources(test_suite PRIVATE $<TARGET_OBJECTS:database>)
|
|
endif()
|
|
|
|
#
|
|
## Link the executables with their libraries
|
|
#
|
|
target_link_libraries(${PROJECT_NAME}
|
|
${ICONV_LIBRARIES}
|
|
${LIBUUID_LIBRARIES}
|
|
${EXPAT_LIBRARY})
|
|
target_link_libraries(test_suite
|
|
${ICONV_LIBRARIES}
|
|
${LIBUUID_LIBRARIES}
|
|
${EXPAT_LIBRARY})
|
|
if(SYSTEMD_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${SYSTEMD_LIBRARIES})
|
|
target_link_libraries(test_suite ${SYSTEMD_LIBRARIES})
|
|
endif()
|
|
if(BOTAN_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${BOTAN_LIBRARIES})
|
|
target_link_libraries(test_suite ${BOTAN_LIBRARIES})
|
|
elseif(GCRYPT_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${GCRYPT_LIBRARIES})
|
|
target_link_libraries(test_suite ${GCRYPT_LIBRARIES})
|
|
endif()
|
|
if(UDNS_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${UDNS_LIBRARIES})
|
|
target_link_libraries(test_suite ${UDNS_LIBRARIES})
|
|
endif()
|
|
if(CURL_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${CURL_LIBRARIES})
|
|
target_link_libraries(test_suite ${CURL_LIBRARIES})
|
|
endif()
|
|
if(LIBIDN_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${LIBIDN_LIBRARIES})
|
|
target_link_libraries(test_suite ${LIBIDN_LIBRARIES})
|
|
endif()
|
|
if(USE_DATABASE)
|
|
if(SQLITE3_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${SQLITE3_LIBRARIES})
|
|
target_link_libraries(test_suite ${SQLITE3_LIBRARIES})
|
|
endif()
|
|
if(PQ_FOUND)
|
|
target_link_libraries(${PROJECT_NAME} ${PQ_LIBRARIES})
|
|
target_link_libraries(test_suite ${PQ_LIBRARIES})
|
|
endif()
|
|
endif()
|
|
|
|
# Define a __FILENAME__ macro with the relative path (from the base project directory)
|
|
# of each source file
|
|
file(GLOB_RECURSE source_all src/*.[hc]pp tests/*.[hc]pp)
|
|
foreach(file ${source_all})
|
|
file(RELATIVE_PATH shorter_file ${CMAKE_CURRENT_SOURCE_DIR} ${file})
|
|
set_property(SOURCE ${file} APPEND PROPERTY COMPILE_DEFINITIONS __FILENAME__="${shorter_file}")
|
|
endforeach()
|
|
|
|
#
|
|
## Catch unit test framework
|
|
#
|
|
find_package(Catch2 3)
|
|
if(Catch2_FOUND)
|
|
target_link_libraries(test_suite Catch2::Catch2WithMain)
|
|
include(CTest)
|
|
include(Catch)
|
|
catch_discover_tests(test_suite)
|
|
endif()
|
|
|
|
#
|
|
## Add some custom rules to launch the tests
|
|
#
|
|
add_custom_target(check COMMAND "test_suite"
|
|
DEPENDS test_suite)
|
|
add_custom_target(check_junit COMMAND test_suite -r junit -o check_result.xml
|
|
DEPENDS test_suite)
|
|
set_target_properties(check PROPERTIES EXCLUDE_FROM_ALL TRUE)
|
|
add_custom_target(e2e COMMAND "python3" "${CMAKE_CURRENT_SOURCE_DIR}/tests/end_to_end/"
|
|
DEPENDS biboumi)
|
|
set_target_properties(e2e PROPERTIES EXCLUDE_FROM_ALL TRUE)
|
|
add_custom_target(e2e_valgrind COMMAND "E2E_BIBOUMI_SUPP_DIR=${CMAKE_CURRENT_SOURCE_DIR}/tests/end_to_end/" "E2E_BIBOUMI_VALGRIND=1" "python3" "${CMAKE_CURRENT_SOURCE_DIR}/tests/end_to_end/"
|
|
DEPENDS biboumi)
|
|
if(CMAKE_BUILD_TYPE MATCHES Debug)
|
|
include(CodeCoverage)
|
|
SETUP_TARGET_FOR_COVERAGE(coverage_check
|
|
./test_suite
|
|
coverage_test_suite
|
|
"-o;check_result.xml;-r;junit")
|
|
add_dependencies(coverage_check test_suite)
|
|
|
|
SETUP_TARGET_FOR_COVERAGE(coverage_e2e
|
|
python3
|
|
coverage_e2e
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/tests/end_to_end/")
|
|
add_dependencies(coverage_e2e biboumi)
|
|
|
|
ADD_CUSTOM_TARGET(coverage
|
|
COMMAND ${LCOV_PATH} -a coverage_e2e.info -a coverage_test_suite.info -o coverage_total.info
|
|
|
|
COMMAND ${GENHTML_PATH} -o coverage_total coverage_total.info
|
|
|
|
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
|
|
)
|
|
endif()
|
|
add_custom_target(everything DEPENDS test_suite biboumi)
|
|
|
|
#
|
|
## Install target
|
|
#
|
|
include(GNUInstallDirs)
|
|
|
|
# From cmake version 4.1 CMAKE_INSTALL_SYSCONFDIR has special behaviour when
|
|
# CMAKE_INSTALL_PREFIX is /, /usr, or /opt/..., so to not update cmake version
|
|
# just yet reimplement this here
|
|
# https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html#special-cases
|
|
if (CMAKE_INSTALL_SYSCONFDIR STREQUAL "etc" AND (CMAKE_INSTALL_PREFIX STREQUAL "/" OR CMAKE_INSTALL_PREFIX STREQUAL "/usr"))
|
|
set(CMAKE_INSTALL_SYSCONFDIR "/etc")
|
|
elseif (CMAKE_INSTALL_SYSCONFDIR STREQUAL "etc" AND (CMAKE_INSTALL_PREFIX MATCHES "^/opt/"))
|
|
set(CMAKE_INSTALL_SYSCONFDIR "/etc${CMAKE_INSTALL_PREFIX}")
|
|
endif()
|
|
|
|
install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
|
|
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/man/biboumi.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 OPTIONAL COMPONENT documentation)
|
|
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/biboumi.service DESTINATION ${CMAKE_INSTALL_PREFIX}/lib/systemd/system COMPONENT init)
|
|
file(GLOB policy_files conf/*policy.txt)
|
|
install(FILES ${policy_files} DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/biboumi COMPONENT configuration)
|
|
|
|
#
|
|
## Dist target
|
|
## Generate a release tarball from the git sources
|
|
#
|
|
add_custom_command(OUTPUT ${ARCHIVE_NAME}.tar.xz
|
|
COMMAND git archive --prefix=${ARCHIVE_NAME}/ --format=tar HEAD^{tree}
|
|
--output=${CMAKE_CURRENT_BINARY_DIR}/${ARCHIVE_NAME}.tar
|
|
# Remove a potential existing archive
|
|
COMMAND rm -f ${CMAKE_CURRENT_BINARY_DIR}/${ARCHIVE_NAME}.tar.xz
|
|
# Compress the archive
|
|
COMMAND xz ${CMAKE_CURRENT_BINARY_DIR}/${ARCHIVE_NAME}.tar
|
|
COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "${ARCHIVE_NAME}.tar.xz created."
|
|
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
|
|
)
|
|
|
|
add_custom_target(dist
|
|
DEPENDS ${ARCHIVE_NAME}.tar.xz)
|
|
|
|
# The forge only provides .tar.gz, so make this target to be used to simulate
|
|
# downloading a tarball
|
|
add_custom_command(OUTPUT ${RPM_VERSION}.tar.gz
|
|
COMMAND git archive --prefix=${ARCHIVE_NAME}/ --format=tar.gz HEAD^{tree}
|
|
--output=${CMAKE_CURRENT_BINARY_DIR}/${RPM_VERSION}.tar.gz
|
|
COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "${RPM_VERSION}.tar.gz created."
|
|
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
|
|
)
|
|
|
|
add_custom_target(rpm
|
|
DEPENDS ${RPM_VERSION}.tar.gz
|
|
COMMAND mkdir -p rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
|
|
COMMAND rpmbuild --define "_topdir `pwd`/rpmbuild/" --define "_sourcedir `pwd`" -ba biboumi.spec
|
|
)
|
|
|
|
#
|
|
## Set some variables that will be used in the cmake-generated files
|
|
#
|
|
set(SYSTEMD_SERVICE_TYPE_DOCSTRING "The value used as the Type= in the systemd unit file.")
|
|
set(WATCHDOG_SEC_DOCSTRING "The value used as WatchdogSec= in the systemd unit file.")
|
|
set(WATCHDOG_SEC "" CACHE STRING ${WATCHDOG_SEC_DOCSTRING})
|
|
if(SYSTEMD_FOUND)
|
|
set(SYSTEMD_SERVICE_TYPE "notify" CACHE STRING ${SYSTEMD_SERVICE_TYPE_DOCSTRING})
|
|
else()
|
|
set(SYSTEMD_SERVICE_TYPE "simple" CACHE STRING ${SYSTEMD_SERVICE_TYPE_DOCSTRING})
|
|
endif()
|
|
set(SERVICE_USER_DOCSTRING "The value used as the User= in the systemd unit file.")
|
|
if(NOT DEFINED SERVICE_USER)
|
|
set(SERVICE_USER "nobody" CACHE STRING ${SERVICE_USER_DOCSTRING})
|
|
endif()
|
|
set(SERVICE_GROUP_DOCSTRING "The value used as the Group= in the systemd unit file.")
|
|
if(NOT DEFINED SERVICE_GROUP)
|
|
set(SERVICE_GROUP "nobody" CACHE STRING ${SERVICE_GROUP_DOCSTRING})
|
|
endif()
|
|
|
|
# Force the format of the date output
|
|
set(ENV{LANG} "C")
|
|
execute_process(COMMAND "date" "+%a %b %d %Y" OUTPUT_VARIABLE RPM_DATE
|
|
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
|
unset(ENV{LANG})
|
|
|
|
set(POLLER_DOCSTRING "Choose the poller between POLL and EPOLL (Linux-only)")
|
|
if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
|
|
set(POLLER "EPOLL" CACHE STRING ${POLLER_DOCSTRING})
|
|
else()
|
|
set(POLLER "POLL" CACHE STRING ${POLLER_DOCSTRING})
|
|
endif()
|
|
if((NOT ${POLLER} MATCHES "POLL") AND
|
|
(NOT ${POLLER} MATCHES "EPOLL"))
|
|
message(FATAL_ERROR "POLLER must be either POLL or EPOLL")
|
|
endif()
|
|
|
|
#
|
|
## Check if we have std::get_time and put_time
|
|
#
|
|
include(CheckCXXSourceCompiles)
|
|
|
|
check_cxx_source_compiles("
|
|
#include <iomanip>
|
|
int main()
|
|
{ std::get_time(nullptr, \"\"); }"
|
|
HAS_GET_TIME)
|
|
|
|
mark_as_advanced(HAS_GET_TIME)
|
|
|
|
check_cxx_source_compiles("
|
|
#include <iomanip>
|
|
int main()
|
|
{ std::put_time(nullptr, \"\"); }"
|
|
HAS_PUT_TIME)
|
|
|
|
mark_as_advanced(HAS_PUT_TIME)
|
|
|
|
configure_file(unit/biboumi.service.cmake biboumi.service)
|
|
configure_file(packaging/biboumi.spec.cmake biboumi.spec)
|
|
configure_file(src/biboumi.h.cmake src/biboumi.h)
|