From 133e6dc2ef51ff42d53948c0023cfca8a2feeadb Mon Sep 17 00:00:00 2001 From: Martin Chang Date: Tue, 24 Aug 2021 16:34:07 +0800 Subject: [PATCH] Update C++ version detection logic (#993) * Maintain compatibility with cmake generated from older drogon_ctl * Use user-defined C++ version when possible * C++ version detection no-longer depends on std::filesystem availability * Link against c++fs in DrogonConfig.cmake if on those versions of GCC * Allow DrogonConfig to use user-defined C++ version --- CMakeLists.txt | 60 ++++--- cmake/templates/DrogonConfig.cmake.in | 4 + cmake_modules/FindFilesystem.cmake | 248 ++++++++++++++++++++++++++ drogon_ctl/templates/cmake.csp | 4 +- 4 files changed, 289 insertions(+), 27 deletions(-) create mode 100644 cmake_modules/FindFilesystem.cmake diff --git a/CMakeLists.txt b/CMakeLists.txt index 56d57008..771ffc84 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -93,10 +93,11 @@ include(CheckIncludeFileCXX) check_include_file_cxx(any HAS_ANY) check_include_file_cxx(string_view HAS_STRING_VIEW) check_include_file_cxx(coroutine HAS_COROUTINE) -check_include_file_cxx(filesystem HAS_FILESYSTEM) -if (HAS_ANY AND HAS_STRING_VIEW AND HAS_COROUTINE AND HAS_FILESYSTEM) +if (NOT "${CMAKE_CXX_STANDARD}" STREQUAL "") + set(DROGON_CXX_STANDARD ${CMAKE_CXX_STANDARD}) +elseif (HAS_ANY AND HAS_STRING_VIEW AND HAS_COROUTINE) set(DROGON_CXX_STANDARD 20) -elseif (HAS_ANY AND HAS_STRING_VIEW AND HAS_FILESYSTEM) +elseif (HAS_ANY AND HAS_STRING_VIEW) set(DROGON_CXX_STANDARD 17) else () set(DROGON_CXX_STANDARD 14) @@ -130,6 +131,14 @@ else (NOT WIN32) target_link_libraries(${PROJECT_NAME} PRIVATE shlwapi) endif (NOT WIN32) +list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake_modules/) + +find_package(Filesystem COMPONENTS Final) +if(CXX_FILESYSTEM_HAVE_FS) + message(STATUS "Found std::filesystem") +endif() + +# Check for C++ filesystem support set(NEED_BOOST_FS 0) if (DROGON_CXX_STANDARD EQUAL 14) # With C++14, use Boost to support any and string_view @@ -143,34 +152,31 @@ if (DROGON_CXX_STANDARD EQUAL 14) elseif (DROGON_CXX_STANDARD EQUAL 17) # With C++17, use Boost if std::filesystem::path is missing message(STATUS "use c++17") + # Check for partial implementation of c++17 (Windows/OSX only?) - set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) - try_compile(check_filesystem_path ${CMAKE_BINARY_DIR}/cmaketest - ${PROJECT_SOURCE_DIR}/cmake/tests/check_has_std_filesystem_path.cc - CXX_STANDARD 17) - set(CMAKE_TRY_COMPILE_TARGET_TYPE) - # Workaround: 2021-08-09 Android NDK does not provide proper std::filesystem - # support. Force boost::filesystem instead. - if (check_filesystem_path AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Android") - message(STATUS "Using c++17 filesytem::path") - if (CMAKE_CXX_COMPILER_ID MATCHES GNU) - target_link_libraries(${PROJECT_NAME} PUBLIC stdc++fs) + if (CXX_FILESYSTEM_HAVE_FS) + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + try_compile(check_filesystem_path ${CMAKE_BINARY_DIR}/cmaketest + ${PROJECT_SOURCE_DIR}/cmake/tests/check_has_std_filesystem_path.cc + CXX_STANDARD 17) + set(CMAKE_TRY_COMPILE_TARGET_TYPE) + if (NOT check_filesystem_path) + message(STATUS "The std::filesystem seems to be a partial implementation" + " Falling back to boost::filesystem") + set(NEED_BOOST_FS 1) endif() - option(HAS_STD_FILESYSTEM_PATH "use std::filesystem" ON) else() - message(STATUS "WORKAROUND: Forcing boost::filesystem on Android") set(NEED_BOOST_FS 1) endif() else () message(STATUS "use c++20") - # Workaround: 2021-08-09 Android NDK does not provide proper std::filesystem - # support. Force boost::filesystem instead. - if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Android") - option(HAS_STD_FILESYSTEM_PATH "use std::filesystem" ON) - else () - message(STATUS "WORKAROUND: Forcing boost::filesystem on Android") - set(NEED_BOOST_FS 1) - endif () +endif () + +# Workaround: 2021-08-09 Android NDK does not provide proper std::filesystem +# support. Force boost::filesystem instead. +if (${CMAKE_SYSTEM_NAME} STREQUAL "Android") + message(STATUS "WORKAROUND: Forcing boost::filesystem on Android") + set(NEED_BOOST_FS 1) endif () if(NEED_BOOST_FS) @@ -182,10 +188,11 @@ if(NEED_BOOST_FS) target_link_libraries(${PROJECT_NAME} PUBLIC Boost::filesystem Boost::system) list(APPEND INCLUDE_DIRS_FOR_DYNAMIC_VIEW ${Boost_INCLUDE_DIR}) option(HAS_STD_FILESYSTEM_PATH "use boost::filesystem" OFF) +else() + option(HAS_STD_FILESYSTEM_PATH "use std::filesystem" ON) + target_link_libraries(${PROJECT_NAME} PUBLIC std::filesystem) endif() -list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake_modules/) - # jsoncpp find_package(Jsoncpp REQUIRED) target_link_libraries(${PROJECT_NAME} PUBLIC Jsoncpp_lib) @@ -699,6 +706,7 @@ install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/FindBrotli.cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/Findcoz-profiler.cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/FindHiredis.cmake" + "${CMAKE_CURRENT_SOURCE_DIR}/cmake_modules/FindFilesystem.cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/DrogonUtilities.cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/ParseAndAddDrogonTests.cmake" DESTINATION "${INSTALL_DROGON_CMAKE_DIR}" diff --git a/cmake/templates/DrogonConfig.cmake.in b/cmake/templates/DrogonConfig.cmake.in index f3fd808f..199cfb9d 100644 --- a/cmake/templates/DrogonConfig.cmake.in +++ b/cmake/templates/DrogonConfig.cmake.in @@ -43,6 +43,10 @@ endif() if(@BUILD_DROGON_SHARED@) find_dependency(Threads) endif() +if(@HAS_STD_FILESYSTEM_PATH@) +find_dependency(Filesystem) +find_package(Filesystem COMPONENTS Final REQUIRED) +endif() # Our library dependencies (contains definitions for IMPORTED targets) diff --git a/cmake_modules/FindFilesystem.cmake b/cmake_modules/FindFilesystem.cmake new file mode 100644 index 00000000..4f51b53f --- /dev/null +++ b/cmake_modules/FindFilesystem.cmake @@ -0,0 +1,248 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: + +FindFilesystem +############## + +This module supports the C++17 standard library's filesystem utilities. Use the +:imp-target:`std::filesystem` imported target to + +Options +******* + +The ``COMPONENTS`` argument to this module supports the following values: + +.. find-component:: Experimental + :name: fs.Experimental + + Allows the module to find the "experimental" Filesystem TS version of the + Filesystem library. This is the library that should be used with the + ``std::experimental::filesystem`` namespace. + +.. find-component:: Final + :name: fs.Final + + Finds the final C++17 standard version of the filesystem library. + +If no components are provided, behaves as if the +:find-component:`fs.Final` component was specified. + +If both :find-component:`fs.Experimental` and :find-component:`fs.Final` are +provided, first looks for ``Final``, and falls back to ``Experimental`` in case +of failure. If ``Final`` is found, :imp-target:`std::filesystem` and all +:ref:`variables ` will refer to the ``Final`` version. + + +Imported Targets +**************** + +.. imp-target:: std::filesystem + + The ``std::filesystem`` imported target is defined when any requested + version of the C++ filesystem library has been found, whether it is + *Experimental* or *Final*. + + If no version of the filesystem library is available, this target will not + be defined. + + .. note:: + This target has ``cxx_std_17`` as an ``INTERFACE`` + :ref:`compile language standard feature `. Linking + to this target will automatically enable C++17 if no later standard + version is already required on the linking target. + + +.. _fs.variables: + +Variables +********* + +.. variable:: CXX_FILESYSTEM_IS_EXPERIMENTAL + + Set to ``TRUE`` when the :find-component:`fs.Experimental` version of C++ + filesystem library was found, otherwise ``FALSE``. + +.. variable:: CXX_FILESYSTEM_HAVE_FS + + Set to ``TRUE`` when a filesystem header was found. + +.. variable:: CXX_FILESYSTEM_HEADER + + Set to either ``filesystem`` or ``experimental/filesystem`` depending on + whether :find-component:`fs.Final` or :find-component:`fs.Experimental` was + found. + +.. variable:: CXX_FILESYSTEM_NAMESPACE + + Set to either ``std::filesystem`` or ``std::experimental::filesystem`` + depending on whether :find-component:`fs.Final` or + :find-component:`fs.Experimental` was found. + + +Examples +******** + +Using `find_package(Filesystem)` with no component arguments: + +.. code-block:: cmake + + find_package(Filesystem REQUIRED) + + add_executable(my-program main.cpp) + target_link_libraries(my-program PRIVATE std::filesystem) + + +#]=======================================================================] + + +if(TARGET std::filesystem) + # This module has already been processed. Don't do it again. + return() +endif() + +cmake_minimum_required(VERSION 3.10) + +include(CMakePushCheckState) +include(CheckIncludeFileCXX) + +# If we're not cross-compiling, try to run test executables. +# Otherwise, assume that compile + link is a sufficient check. +if(CMAKE_CROSSCOMPILING) + include(CheckCXXSourceCompiles) + macro(_cmcm_check_cxx_source code var) + check_cxx_source_compiles("${code}" ${var}) + endmacro() +else() + include(CheckCXXSourceRuns) + macro(_cmcm_check_cxx_source code var) + check_cxx_source_runs("${code}" ${var}) + endmacro() +endif() + +cmake_push_check_state() + +set(CMAKE_REQUIRED_QUIET ${Filesystem_FIND_QUIETLY}) + +# All of our tests required C++17 or later +set(CMAKE_CXX_STANDARD 17) + +# Normalize and check the component list we were given +set(want_components ${Filesystem_FIND_COMPONENTS}) +if(Filesystem_FIND_COMPONENTS STREQUAL "") + set(want_components Final) +endif() + +# Warn on any unrecognized components +set(extra_components ${want_components}) +list(REMOVE_ITEM extra_components Final Experimental) +foreach(component IN LISTS extra_components) + message(WARNING "Extraneous find_package component for Filesystem: ${component}") +endforeach() + +# Detect which of Experimental and Final we should look for +set(find_experimental TRUE) +set(find_final TRUE) +if(NOT "Final" IN_LIST want_components) + set(find_final FALSE) +endif() +if(NOT "Experimental" IN_LIST want_components) + set(find_experimental FALSE) +endif() + +if(find_final) + check_include_file_cxx("filesystem" _CXX_FILESYSTEM_HAVE_HEADER) + mark_as_advanced(_CXX_FILESYSTEM_HAVE_HEADER) + if(_CXX_FILESYSTEM_HAVE_HEADER) + # We found the non-experimental header. Don't bother looking for the + # experimental one. + set(find_experimental FALSE) + endif() +else() + set(_CXX_FILESYSTEM_HAVE_HEADER FALSE) +endif() + +if(find_experimental) + check_include_file_cxx("experimental/filesystem" _CXX_FILESYSTEM_HAVE_EXPERIMENTAL_HEADER) + mark_as_advanced(_CXX_FILESYSTEM_HAVE_EXPERIMENTAL_HEADER) +else() + set(_CXX_FILESYSTEM_HAVE_EXPERIMENTAL_HEADER FALSE) +endif() + +if(_CXX_FILESYSTEM_HAVE_HEADER) + set(_have_fs TRUE) + set(_fs_header filesystem) + set(_fs_namespace std::filesystem) + set(_is_experimental FALSE) +elseif(_CXX_FILESYSTEM_HAVE_EXPERIMENTAL_HEADER) + set(_have_fs TRUE) + set(_fs_header experimental/filesystem) + set(_fs_namespace std::experimental::filesystem) + set(_is_experimental TRUE) +else() + set(_have_fs FALSE) +endif() + +set(CXX_FILESYSTEM_HAVE_FS ${_have_fs} CACHE BOOL "TRUE if we have the C++ filesystem headers") +set(CXX_FILESYSTEM_HEADER ${_fs_header} CACHE STRING "The header that should be included to obtain the filesystem APIs") +set(CXX_FILESYSTEM_NAMESPACE ${_fs_namespace} CACHE STRING "The C++ namespace that contains the filesystem APIs") +set(CXX_FILESYSTEM_IS_EXPERIMENTAL ${_is_experimental} CACHE BOOL "TRUE if the C++ filesystem library is the experimental version") + +set(_found FALSE) + +if(CXX_FILESYSTEM_HAVE_FS) + # We have some filesystem library available. Do link checks + string(CONFIGURE [[ + #include + #include <@CXX_FILESYSTEM_HEADER@> + + int main() { + auto cwd = @CXX_FILESYSTEM_NAMESPACE@::current_path(); + printf("%s", cwd.c_str()); + return EXIT_SUCCESS; + } + ]] code @ONLY) + + # Check a simple filesystem program without any linker flags + _cmcm_check_cxx_source("${code}" CXX_FILESYSTEM_NO_LINK_NEEDED) + + set(can_link ${CXX_FILESYSTEM_NO_LINK_NEEDED}) + + if(NOT CXX_FILESYSTEM_NO_LINK_NEEDED) + set(prev_libraries ${CMAKE_REQUIRED_LIBRARIES}) + # Add the libstdc++ flag + set(CMAKE_REQUIRED_LIBRARIES ${prev_libraries} -lstdc++fs) + _cmcm_check_cxx_source("${code}" CXX_FILESYSTEM_STDCPPFS_NEEDED) + set(can_link ${CXX_FILESYSTEM_STDCPPFS_NEEDED}) + if(NOT CXX_FILESYSTEM_STDCPPFS_NEEDED) + # Try the libc++ flag + set(CMAKE_REQUIRED_LIBRARIES ${prev_libraries} -lc++fs) + _cmcm_check_cxx_source("${code}" CXX_FILESYSTEM_CPPFS_NEEDED) + set(can_link ${CXX_FILESYSTEM_CPPFS_NEEDED}) + endif() + endif() + + if(can_link) + add_library(std::filesystem INTERFACE IMPORTED) + set_property(TARGET std::filesystem APPEND PROPERTY INTERFACE_COMPILE_FEATURES cxx_std_17) + set(_found TRUE) + + if(CXX_FILESYSTEM_NO_LINK_NEEDED) + # Nothing to add... + elseif(CXX_FILESYSTEM_STDCPPFS_NEEDED) + set_property(TARGET std::filesystem APPEND PROPERTY INTERFACE_LINK_LIBRARIES -lstdc++fs) + elseif(CXX_FILESYSTEM_CPPFS_NEEDED) + set_property(TARGET std::filesystem APPEND PROPERTY INTERFACE_LINK_LIBRARIES -lc++fs) + endif() + endif() +endif() + +cmake_pop_check_state() + +set(Filesystem_FOUND ${_found} CACHE BOOL "TRUE if we can run a program using std::filesystem" FORCE) + +if(Filesystem_FIND_REQUIRED AND NOT Filesystem_FOUND) + message(FATAL_ERROR "Cannot run simple program using std::filesystem") +endif() + diff --git a/drogon_ctl/templates/cmake.csp b/drogon_ctl/templates/cmake.csp index d49cf1fb..cbaf5261 100644 --- a/drogon_ctl/templates/cmake.csp +++ b/drogon_ctl/templates/cmake.csp @@ -6,7 +6,9 @@ include(CheckIncludeFileCXX) check_include_file_cxx(any HAS_ANY) check_include_file_cxx(string_view HAS_STRING_VIEW) check_include_file_cxx(coroutine HAS_COROUTINE) -if (HAS_ANY AND HAS_STRING_VIEW AND HAS_COROUTINE) +if (NOT "${CMAKE_CXX_STANDARD}" STREQUAL "") + # Do nothing +elseif (HAS_ANY AND HAS_STRING_VIEW AND HAS_COROUTINE) set(CMAKE_CXX_STANDARD 20) elseif (HAS_ANY AND HAS_STRING_VIEW) set(CMAKE_CXX_STANDARD 17)