Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-21 20:55:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

format: apply cmake-format

Browse Source
This commit is contained in:
Henry Schreiner 2020-07-30 16:20:10 -04:00 committed by Henry Schreiner
parent e2a96890e1
commit 94db5c5ed1
15 changed files with 472 additions and 402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.cmake-format.yaml
View File

@ -67,3 +67,7 @@ format:
# If true, the parsers may infer whether or not an argument # If true, the parsers may infer whether or not an argument
# list is sortable (without annotation). # list is sortable (without annotation).
autosort: false autosort: false
# Causes a few issues - can be solved later, possibly.
markup:
enable_markup: false

225
CMakeLists.txt
View File

@ -10,37 +10,30 @@ cmake_minimum_required(VERSION 3.7)
# VERSION 3.7...3.18, but some versions of MCVS have a patched CMake 3.11 # VERSION 3.7...3.18, but some versions of MCVS have a patched CMake 3.11
# that do not work properly with this syntax, so using the following workaround: # that do not work properly with this syntax, so using the following workaround:
if(${CMAKE_VERSION} VERSION_LESS 3.18) if(${CMAKE_VERSION} VERSION_LESS 3.18)
cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}) cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
else() else()
cmake_policy(VERSION 3.18) cmake_policy(VERSION 3.18)
endif() endif()
# Extract project version from source # Extract project version from source
file( file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/pybind11/detail/common.h"
STRINGS pybind11_version_defines REGEX "#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) ")
"${CMAKE_CURRENT_SOURCE_DIR}/include/pybind11/detail/common.h"
pybind11_version_defines
REGEX
"#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) ")
foreach(ver ${pybind11_version_defines}) foreach(ver ${pybind11_version_defines})
if (ver MATCHES [[#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$]]) if(ver MATCHES [[#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$]])
set(PYBIND11_VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}") set(PYBIND11_VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}")
endif() endif()
endforeach() endforeach()
if(PYBIND11_VERSION_PATCH MATCHES [[([a-zA-Z]+)]]) if(PYBIND11_VERSION_PATCH MATCHES [[([a-zA-Z]+)]])
set(PYBIND11_VERSION_TYPE "${CMAKE_MATCH_1}") set(PYBIND11_VERSION_TYPE "${CMAKE_MATCH_1}")
endif() endif()
string(REGEX MATCH "[0-9]+" PYBIND11_VERSION_PATCH "${PYBIND11_VERSION_PATCH}") string(REGEX MATCH "[0-9]+" PYBIND11_VERSION_PATCH "${PYBIND11_VERSION_PATCH}")
project( project(
pybind11 pybind11
LANGUAGES LANGUAGES CXX
CXX VERSION "${PYBIND11_VERSION_MAJOR}.${PYBIND11_VERSION_MINOR}.${PYBIND11_VERSION_PATCH}")
VERSION
"${PYBIND11_VERSION_MAJOR}.${PYBIND11_VERSION_MINOR}.${PYBIND11_VERSION_PATCH}"
)
# Standard includes # Standard includes
include(GNUInstallDirs) include(GNUInstallDirs)
@ -51,26 +44,25 @@ message(STATUS "pybind11 v${pybind11_VERSION} ${PYBIND11_VERSION_TYPE}")
# Check if pybind11 is being used directly or via add_subdirectory # Check if pybind11 is being used directly or via add_subdirectory
if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
set(PYBIND11_MASTER_PROJECT ON) set(PYBIND11_MASTER_PROJECT ON)
message(STATUS "CMake ${CMAKE_VERSION}") message(STATUS "CMake ${CMAKE_VERSION}")
if(CMAKE_CXX_STANDARD) if(CMAKE_CXX_STANDARD)
set(CMAKE_CXX_EXTENSIONS OFF) set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD_REQUIRED ON)
endif() endif()
else() else()
set(PYBIND11_MASTER_PROJECT OFF) set(PYBIND11_MASTER_PROJECT OFF)
set(pybind11_system SYSTEM) set(pybind11_system SYSTEM)
endif() endif()
option(PYBIND11_INSTALL "Install pybind11 header files?" ${PYBIND11_MASTER_PROJECT}) option(PYBIND11_INSTALL "Install pybind11 header files?" ${PYBIND11_MASTER_PROJECT})
option(PYBIND11_TEST "Build pybind11 test suite?" ${PYBIND11_MASTER_PROJECT}) option(PYBIND11_TEST "Build pybind11 test suite?" ${PYBIND11_MASTER_PROJECT})
option(PYBIND11_CLASSIC_LTO "Use the classic LTO flag algorithm, even on CMake 3.9+" OFF) option(PYBIND11_CLASSIC_LTO "Use the classic LTO flag algorithm, even on CMake 3.9+" OFF)
cmake_dependent_option( cmake_dependent_option(
USE_PYTHON_INCLUDE_DIR USE_PYTHON_INCLUDE_DIR
"Install pybind11 headers in Python include directory instead of default installation prefix" OFF "Install pybind11 headers in Python include directory instead of default installation prefix"
"PYBIND11_INSTALL" OFF OFF "PYBIND11_INSTALL" OFF)
)
# NB: when adding a header don't forget to also add it to setup.py # NB: when adding a header don't forget to also add it to setup.py
set(PYBIND11_HEADERS set(PYBIND11_HEADERS
@ -96,16 +88,14 @@ set(PYBIND11_HEADERS
include/pybind11/pybind11.h include/pybind11/pybind11.h
include/pybind11/pytypes.h include/pybind11/pytypes.h
include/pybind11/stl.h include/pybind11/stl.h
include/pybind11/stl_bind.h include/pybind11/stl_bind.h)
)
# TODO: compare with grep and warn if missmatched # TODO: compare with grep and warn if missmatched
# cmake 3.12 added list(TRANSFORM <list> PREPEND # cmake 3.12 added list(TRANSFORM <list> PREPEND
# But we can't use it yet # But we can't use it yet
string(REPLACE "include/" "${CMAKE_CURRENT_SOURCE_DIR}/include/" string(REPLACE "include/" "${CMAKE_CURRENT_SOURCE_DIR}/include/" PYBIND11_HEADERS
PYBIND11_HEADERS "${PYBIND11_HEADERS}") "${PYBIND11_HEADERS}")
# Classic mode # Classic mode
@ -113,23 +103,37 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools")
include(pybind11Tools) include(pybind11Tools)
# Cache variables so pybind11_add_module can be used in parent projects # Cache variables so pybind11_add_module can be used in parent projects
set(PYBIND11_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/include" CACHE INTERNAL "") set(PYBIND11_INCLUDE_DIR
set(PYTHON_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS} CACHE INTERNAL "") "${CMAKE_CURRENT_LIST_DIR}/include"
set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} CACHE INTERNAL "") CACHE INTERNAL "")
set(PYTHON_MODULE_PREFIX ${PYTHON_MODULE_PREFIX} CACHE INTERNAL "") set(PYTHON_INCLUDE_DIRS
set(PYTHON_MODULE_EXTENSION ${PYTHON_MODULE_EXTENSION} CACHE INTERNAL "") ${PYTHON_INCLUDE_DIRS}
set(PYTHON_VERSION_MAJOR ${PYTHON_VERSION_MAJOR} CACHE INTERNAL "") CACHE INTERNAL "")
set(PYTHON_VERSION_MINOR ${PYTHON_VERSION_MINOR} CACHE INTERNAL "") set(PYTHON_LIBRARIES
set(PYTHON_IS_DEBUG "${PYTHON_IS_DEBUG}" CACHE INTERNAL "") ${PYTHON_LIBRARIES}
CACHE INTERNAL "")
set(PYTHON_MODULE_PREFIX
${PYTHON_MODULE_PREFIX}
CACHE INTERNAL "")
set(PYTHON_MODULE_EXTENSION
${PYTHON_MODULE_EXTENSION}
CACHE INTERNAL "")
set(PYTHON_VERSION_MAJOR
${PYTHON_VERSION_MAJOR}
CACHE INTERNAL "")
set(PYTHON_VERSION_MINOR
${PYTHON_VERSION_MINOR}
CACHE INTERNAL "")
set(PYTHON_IS_DEBUG
"${PYTHON_IS_DEBUG}"
CACHE INTERNAL "")
if(PYBIND11_TEST OR (BUILD_TESTING AND PYBIND11_MASTER_PROJECT)) if(PYBIND11_TEST OR (BUILD_TESTING AND PYBIND11_MASTER_PROJECT))
add_subdirectory(tests) add_subdirectory(tests)
endif() endif()
if(USE_PYTHON_INCLUDE_DIR) if(USE_PYTHON_INCLUDE_DIR)
file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${PYTHON_INCLUDE_DIRS}) file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${PYTHON_INCLUDE_DIRS})
endif() endif()
# Note: when creating targets, you cannot use if statements at configure time - # Note: when creating targets, you cannot use if statements at configure time -
@ -138,26 +142,22 @@ endif()
# Build an interface library target: # Build an interface library target:
add_library(pybind11 INTERFACE) add_library(pybind11 INTERFACE)
add_library(pybind11::pybind11 ALIAS pybind11) # to match exported target add_library(pybind11::pybind11 ALIAS pybind11) # to match exported target
target_include_directories(pybind11 ${pybind11_system} INTERFACE $<BUILD_INTERFACE:${PYBIND11_INCLUDE_DIR}> target_include_directories(
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>) pybind11 ${pybind11_system} INTERFACE $<BUILD_INTERFACE:${PYBIND11_INCLUDE_DIR}>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
# Only add Python for build - must be added during the import for config since it has to be re-discovered. # Only add Python for build - must be added during the import for config since it has to be re-discovered.
target_include_directories(pybind11 SYSTEM INTERFACE $<BUILD_INTERFACE:${PYTHON_INCLUDE_DIRS}>) target_include_directories(pybind11 SYSTEM INTERFACE $<BUILD_INTERFACE:${PYTHON_INCLUDE_DIRS}>)
if(CMAKE_VERSION VERSION_LESS 3.13) if(CMAKE_VERSION VERSION_LESS 3.13)
target_compile_features( target_compile_features(pybind11 INTERFACE cxx_inheriting_constructors cxx_user_literals
pybind11 cxx_right_angle_brackets)
INTERFACE
cxx_inheriting_constructors
cxx_user_literals
cxx_right_angle_brackets
)
else() else()
# This was added in CMake 3.8, but we are keeping a consistent breaking # This was added in CMake 3.8, but we are keeping a consistent breaking
# point for the config file at 3.13. A config generated by CMake 3.13+ # point for the config file at 3.13. A config generated by CMake 3.13+
# can only be read in 3.13+ due to the SHELL usage later, so this is safe to do. # can only be read in 3.13+ due to the SHELL usage later, so this is safe to do.
target_compile_features(pybind11 INTERFACE cxx_std_11) target_compile_features(pybind11 INTERFACE cxx_std_11)
endif() endif()
add_library(module INTERFACE) add_library(module INTERFACE)
@ -167,23 +167,26 @@ target_link_libraries(module INTERFACE pybind11::pybind11)
# See https://github.com/Kitware/CMake/blob/master/Modules/CMakePlatformId.h.in for platform IDs # See https://github.com/Kitware/CMake/blob/master/Modules/CMakePlatformId.h.in for platform IDs
# Note: CMake 3.15 allows $<PLATFORM_ID:Windows,Cygwin> # Note: CMake 3.15 allows $<PLATFORM_ID:Windows,Cygwin>
target_link_libraries(module INTERFACE "$<$<OR:$<PLATFORM_ID:Windows>,$<PLATFORM_ID:Cygwin>>:$<BUILD_INTERFACE:${PYTHON_LIBRARIES}>>") target_link_libraries(
module
INTERFACE
"$<$<OR:$<PLATFORM_ID:Windows>,$<PLATFORM_ID:Cygwin>>:$<BUILD_INTERFACE:${PYTHON_LIBRARIES}>>")
if(CMAKE_VERSION VERSION_LESS 3.13) if(CMAKE_VERSION VERSION_LESS 3.13)
target_link_libraries(module INTERFACE "$<$<PLATFORM_ID:Darwin>:-undefined dynamic_lookup>") target_link_libraries(module INTERFACE "$<$<PLATFORM_ID:Darwin>:-undefined dynamic_lookup>")
else() else()
# SHELL (3.12+) forces this to remain together, and link_options was added in 3.13+ # SHELL (3.12+) forces this to remain together, and link_options was added in 3.13+
# This is safer, because you are ensured the deduplication pass in CMake will not consider # This is safer, because you are ensured the deduplication pass in CMake will not consider
# these separate and remove one but not the other. # these separate and remove one but not the other.
target_link_options(module INTERFACE "$<$<PLATFORM_ID:Darwin>:SHELL:-undefined dynamic_lookup>") target_link_options(module INTERFACE "$<$<PLATFORM_ID:Darwin>:SHELL:-undefined dynamic_lookup>")
endif() endif()
# Workaround for Python 2.7 and C++17 (C++14 as a warning) incompatibility # Workaround for Python 2.7 and C++17 (C++14 as a warning) incompatibility
# This adds the flags -Wno-register and -Wno-deprecated-register if the compiler # This adds the flags -Wno-register and -Wno-deprecated-register if the compiler
# is Clang 3.9+ or AppleClang and the compile language is CXX, or /wd5033 for MSVC (all languages, # is Clang 3.9+ or AppleClang and the compile language is CXX, or /wd5033 for MSVC (all languages,
# since MSVC didn't recognize COMPILE_LANGUAGE until CMake 3.11+). # since MSVC didn't recognize COMPILE_LANGUAGE until CMake 3.11+).
set(clang_4plus "$<AND:$<CXX_COMPILER_ID:Clang>,$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,3.9>>>") set(clang_4plus
"$<AND:$<CXX_COMPILER_ID:Clang>,$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,3.9>>>")
set(no_register "$<OR:${clang_4plus},$<CXX_COMPILER_ID:AppleClang>>") set(no_register "$<OR:${clang_4plus},$<CXX_COMPILER_ID:AppleClang>>")
set(cxx_no_register "$<AND:$<COMPILE_LANGUAGE:CXX>,${no_register}>") set(cxx_no_register "$<AND:$<COMPILE_LANGUAGE:CXX>,${no_register}>")
set(msvc "$<CXX_COMPILER_ID:MSVC>") set(msvc "$<CXX_COMPILER_ID:MSVC>")
@ -196,58 +199,50 @@ add_library(pybind11::embed ALIAS embed)
target_link_libraries(embed INTERFACE pybind11::pybind11 $<BUILD_INTERFACE:${PYTHON_LIBRARIES}>) target_link_libraries(embed INTERFACE pybind11::pybind11 $<BUILD_INTERFACE:${PYTHON_LIBRARIES}>)
if(PYBIND11_INSTALL) if(PYBIND11_INSTALL)
install(DIRECTORY ${PYBIND11_INCLUDE_DIR}/pybind11 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) install(DIRECTORY ${PYBIND11_INCLUDE_DIR}/pybind11 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
# GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share". # GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
set(PYBIND11_CMAKECONFIG_INSTALL_DIR "share/cmake/${PROJECT_NAME}" CACHE STRING "install path for pybind11Config.cmake") set(PYBIND11_CMAKECONFIG_INSTALL_DIR
"share/cmake/${PROJECT_NAME}"
CACHE STRING "install path for pybind11Config.cmake")
configure_package_config_file(tools/${PROJECT_NAME}Config.cmake.in configure_package_config_file(
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" tools/${PROJECT_NAME}Config.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
INSTALL_DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR}) INSTALL_DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
if(CMAKE_VERSION VERSION_LESS 3.14) if(CMAKE_VERSION VERSION_LESS 3.14)
# Remove CMAKE_SIZEOF_VOID_P from ConfigVersion.cmake since the library does # Remove CMAKE_SIZEOF_VOID_P from ConfigVersion.cmake since the library does
# not depend on architecture specific settings or libraries. # not depend on architecture specific settings or libraries.
set(_PYBIND11_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P}) set(_PYBIND11_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})
unset(CMAKE_SIZEOF_VOID_P) unset(CMAKE_SIZEOF_VOID_P)
write_basic_package_version_file( write_basic_package_version_file(
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION VERSION ${PROJECT_VERSION}
${PROJECT_VERSION} COMPATIBILITY AnyNewerVersion)
COMPATIBILITY
AnyNewerVersion
)
set(CMAKE_SIZEOF_VOID_P ${_PYBIND11_CMAKE_SIZEOF_VOID_P}) set(CMAKE_SIZEOF_VOID_P ${_PYBIND11_CMAKE_SIZEOF_VOID_P})
else() else()
# CMake 3.14+ natively supports header-only libraries # CMake 3.14+ natively supports header-only libraries
write_basic_package_version_file( write_basic_package_version_file(
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION VERSION ${PROJECT_VERSION}
${PROJECT_VERSION} COMPATIBILITY AnyNewerVersion ARCH_INDEPENDENT)
COMPATIBILITY endif()
AnyNewerVersion
ARCH_INDEPENDENT
)
endif()
install( install(
FILES FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake tools/FindPythonLibsNew.cmake tools/pybind11Tools.cmake
tools/FindPythonLibsNew.cmake DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
tools/pybind11Tools.cmake
DESTINATION
${PYBIND11_CMAKECONFIG_INSTALL_DIR})
if(NOT PYBIND11_EXPORT_NAME) if(NOT PYBIND11_EXPORT_NAME)
set(PYBIND11_EXPORT_NAME "${PROJECT_NAME}Targets") set(PYBIND11_EXPORT_NAME "${PROJECT_NAME}Targets")
endif() endif()
install(TARGETS pybind11 module embed install(TARGETS pybind11 module embed EXPORT "${PYBIND11_EXPORT_NAME}")
EXPORT "${PYBIND11_EXPORT_NAME}")
install(EXPORT "${PYBIND11_EXPORT_NAME}" install(
NAMESPACE "pybind11::" EXPORT "${PYBIND11_EXPORT_NAME}"
DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR}) NAMESPACE "pybind11::"
DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
endif() endif()

178
tests/CMakeLists.txt
View File

@ -10,84 +10,91 @@ cmake_minimum_required(VERSION 3.7)
# VERSION 3.7...3.18, but some versions of VS have a patched CMake 3.11 # VERSION 3.7...3.18, but some versions of VS have a patched CMake 3.11
# that do not work properly with this syntax, so using the following workaround: # that do not work properly with this syntax, so using the following workaround:
if(${CMAKE_VERSION} VERSION_LESS 3.18) if(${CMAKE_VERSION} VERSION_LESS 3.18)
cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}) cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
else() else()
cmake_policy(VERSION 3.18) cmake_policy(VERSION 3.18)
endif() endif()
# There's no harm in including a project in a project # There's no harm in including a project in a project
project(pybind11_tests CXX) project(pybind11_tests CXX)
option(PYBIND11_WERROR "Report all warnings as errors" OFF) option(PYBIND11_WERROR "Report all warnings as errors" OFF)
option(DOWNLOAD_EIGEN "Download EIGEN (requires CMake 3.11+)" OFF) option(DOWNLOAD_EIGEN "Download EIGEN (requires CMake 3.11+)" OFF)
set(PYBIND11_TEST_OVERRIDE "" CACHE STRING "Tests from ;-separated list of *.cpp files will be built instead of all tests") set(PYBIND11_TEST_OVERRIDE
""
CACHE STRING "Tests from ;-separated list of *.cpp files will be built instead of all tests")
if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
# We're being loaded directly, i.e. not via add_subdirectory, so make this # We're being loaded directly, i.e. not via add_subdirectory, so make this
# work as its own project and load the pybind11Config to get the tools we need # work as its own project and load the pybind11Config to get the tools we need
find_package(pybind11 REQUIRED CONFIG) find_package(pybind11 REQUIRED CONFIG)
endif() endif()
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "Setting tests build type to MinSizeRel as none was specified") message(STATUS "Setting tests build type to MinSizeRel as none was specified")
set(CMAKE_BUILD_TYPE MinSizeRel CACHE STRING "Choose the type of build." FORCE) set(CMAKE_BUILD_TYPE
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" MinSizeRel
"MinSizeRel" "RelWithDebInfo") CACHE STRING "Choose the type of build." FORCE)
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel"
"RelWithDebInfo")
endif() endif()
# Full set of test files (you can override these; see below) # Full set of test files (you can override these; see below)
set(PYBIND11_TEST_FILES set(PYBIND11_TEST_FILES
test_async.cpp test_async.cpp
test_buffers.cpp test_buffers.cpp
test_builtin_casters.cpp test_builtin_casters.cpp
test_call_policies.cpp test_call_policies.cpp
test_callbacks.cpp test_callbacks.cpp
test_chrono.cpp test_chrono.cpp
test_class.cpp test_class.cpp
test_constants_and_functions.cpp test_constants_and_functions.cpp
test_copy_move.cpp test_copy_move.cpp
test_custom_type_casters.cpp test_custom_type_casters.cpp
test_docstring_options.cpp test_docstring_options.cpp
test_eigen.cpp test_eigen.cpp
test_enum.cpp test_enum.cpp
test_eval.cpp test_eval.cpp
test_exceptions.cpp test_exceptions.cpp
test_factory_constructors.cpp test_factory_constructors.cpp
test_gil_scoped.cpp test_gil_scoped.cpp
test_iostream.cpp test_iostream.cpp
test_kwargs_and_defaults.cpp test_kwargs_and_defaults.cpp
test_local_bindings.cpp test_local_bindings.cpp
test_methods_and_attributes.cpp test_methods_and_attributes.cpp
test_modules.cpp test_modules.cpp
test_multiple_inheritance.cpp test_multiple_inheritance.cpp
test_numpy_array.cpp test_numpy_array.cpp
test_numpy_dtypes.cpp test_numpy_dtypes.cpp
test_numpy_vectorize.cpp test_numpy_vectorize.cpp
test_opaque_types.cpp test_opaque_types.cpp
test_operator_overloading.cpp test_operator_overloading.cpp
test_pickling.cpp test_pickling.cpp
test_pytypes.cpp test_pytypes.cpp
test_sequences_and_iterators.cpp test_sequences_and_iterators.cpp
test_smart_ptr.cpp test_smart_ptr.cpp
test_stl.cpp test_stl.cpp
test_stl_binders.cpp test_stl_binders.cpp
test_tagbased_polymorphic.cpp test_tagbased_polymorphic.cpp
test_union.cpp test_union.cpp
test_virtual_functions.cpp test_virtual_functions.cpp)
)
# Invoking cmake with something like: # Invoking cmake with something like:
# cmake -DPYBIND11_TEST_OVERRIDE="test_callbacks.cpp;test_picking.cpp" .. # cmake -DPYBIND11_TEST_OVERRIDE="test_callbacks.cpp;test_picking.cpp" ..
# lets you override the tests that get compiled and run. You can restore to all tests with: # lets you override the tests that get compiled and run. You can restore to all tests with:
# cmake -DPYBIND11_TEST_OVERRIDE= .. # cmake -DPYBIND11_TEST_OVERRIDE= ..
if (PYBIND11_TEST_OVERRIDE) if(PYBIND11_TEST_OVERRIDE)
set(PYBIND11_TEST_FILES ${PYBIND11_TEST_OVERRIDE}) set(PYBIND11_TEST_FILES ${PYBIND11_TEST_OVERRIDE})
endif() endif()
# Skip test_async for Python < 3.5 # Skip test_async for Python < 3.5
list(FIND PYBIND11_TEST_FILES test_async.cpp PYBIND11_TEST_FILES_ASYNC_I) list(FIND PYBIND11_TEST_FILES test_async.cpp PYBIND11_TEST_FILES_ASYNC_I)
if((PYBIND11_TEST_FILES_ASYNC_I GREATER -1) AND ("${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}" VERSION_LESS 3.5)) if((PYBIND11_TEST_FILES_ASYNC_I GREATER -1) AND ("${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}"
message(STATUS "Skipping test_async because Python version ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} < 3.5") VERSION_LESS 3.5))
message(
STATUS
"Skipping test_async because Python version ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} < 3.5"
)
list(REMOVE_AT PYBIND11_TEST_FILES ${PYBIND11_TEST_FILES_ASYNC_I}) list(REMOVE_AT PYBIND11_TEST_FILES ${PYBIND11_TEST_FILES_ASYNC_I})
endif() endif()
@ -96,16 +103,10 @@ string(REPLACE ".cpp" ".py" PYBIND11_PYTEST_FILES "${PYBIND11_TEST_FILES}")
# Contains the set of test files that require pybind11_cross_module_tests to be # Contains the set of test files that require pybind11_cross_module_tests to be
# built; if none of these are built (i.e. because TEST_OVERRIDE is used and # built; if none of these are built (i.e. because TEST_OVERRIDE is used and
# doesn't include them) the second module doesn't get built. # doesn't include them) the second module doesn't get built.
set(PYBIND11_CROSS_MODULE_TESTS set(PYBIND11_CROSS_MODULE_TESTS test_exceptions.py test_local_bindings.py test_stl.py
test_exceptions.py test_stl_binders.py)
test_local_bindings.py
test_stl.py
test_stl_binders.py
)
set(PYBIND11_CROSS_MODULE_GIL_TESTS set(PYBIND11_CROSS_MODULE_GIL_TESTS test_gil_scoped.py)
test_gil_scoped.py
)
# Check if Eigen is available; if not, remove from PYBIND11_TEST_FILES (but # Check if Eigen is available; if not, remove from PYBIND11_TEST_FILES (but
# keep it in PYBIND11_PYTEST_FILES, so that we get the "eigen is not installed" # keep it in PYBIND11_PYTEST_FILES, so that we get the "eigen is not installed"
@ -126,8 +127,7 @@ if(PYBIND11_TEST_FILES_EIGEN_I GREATER -1)
FetchContent_Declare( FetchContent_Declare(
eigen eigen
GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
GIT_TAG ${EIGEN3_VERSION_STRING} GIT_TAG ${EIGEN3_VERSION_STRING})
)
FetchContent_GetProperties(eigen) FetchContent_GetProperties(eigen)
if(NOT eigen_POPULATED) if(NOT eigen_POPULATED)
@ -139,13 +139,13 @@ if(PYBIND11_TEST_FILES_EIGEN_I GREATER -1)
set(EIGEN3_FOUND TRUE) set(EIGEN3_FOUND TRUE)
else() else()
find_package(Eigen3 3.2.7 QUIET CONFIG) find_package(Eigen3 3.2.7 QUIET CONFIG)
if (EIGEN3_FOUND) if(EIGEN3_FOUND)
if (EIGEN3_VERSION_STRING AND NOT EIGEN3_VERSION_STRING VERSION_LESS 3.3.1) if(EIGEN3_VERSION_STRING AND NOT EIGEN3_VERSION_STRING VERSION_LESS 3.3.1)
set(PYBIND11_EIGEN_VIA_TARGET TRUE) set(PYBIND11_EIGEN_VIA_TARGET TRUE)
endif() endif()
endif() endif()
if (NOT EIGEN3_FOUND) if(NOT EIGEN3_FOUND)
# Couldn't load via target, so fall back to allowing module mode finding, which will pick up # Couldn't load via target, so fall back to allowing module mode finding, which will pick up
# tools/FindEigen3.cmake # tools/FindEigen3.cmake
find_package(Eigen3 3.2.7 QUIET) find_package(Eigen3 3.2.7 QUIET)
@ -174,7 +174,8 @@ function(pybind11_enable_warnings target_name)
if(MSVC) if(MSVC)
target_compile_options(${target_name} PRIVATE /W4) target_compile_options(${target_name} PRIVATE /W4)
elseif(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Intel|Clang)") elseif(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Intel|Clang)")
target_compile_options(${target_name} PRIVATE -Wall -Wextra -Wconversion -Wcast-qual -Wdeprecated) target_compile_options(${target_name} PRIVATE -Wall -Wextra -Wconversion -Wcast-qual
-Wdeprecated)
endif() endif()
if(PYBIND11_WERROR) if(PYBIND11_WERROR)
@ -186,7 +187,9 @@ function(pybind11_enable_warnings target_name)
endif() endif()
# Needs to be readded since the ordering requires these to be after the ones above # Needs to be readded since the ordering requires these to be after the ones above
if(CMAKE_CXX_STANDARD AND CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND PYTHON_VERSION VERSION_LESS 3.0) if(CMAKE_CXX_STANDARD
AND CMAKE_CXX_COMPILER_ID MATCHES "Clang"
AND PYTHON_VERSION VERSION_LESS 3.0)
if(CMAKE_CXX_STANDARD LESS 17) if(CMAKE_CXX_STANDARD LESS 17)
target_compile_options(${target_name} PUBLIC -Wno-deprecated-register) target_compile_options(${target_name} PUBLIC -Wno-deprecated-register)
else() else()
@ -200,7 +203,7 @@ set(test_targets pybind11_tests)
# Build pybind11_cross_module_tests if any test_whatever.py are being built that require it # Build pybind11_cross_module_tests if any test_whatever.py are being built that require it
foreach(t ${PYBIND11_CROSS_MODULE_TESTS}) foreach(t ${PYBIND11_CROSS_MODULE_TESTS})
list(FIND PYBIND11_PYTEST_FILES ${t} i) list(FIND PYBIND11_PYTEST_FILES ${t} i)
if (i GREATER -1) if(i GREATER -1)
list(APPEND test_targets pybind11_cross_module_tests) list(APPEND test_targets pybind11_cross_module_tests)
break() break()
endif() endif()
@ -208,7 +211,7 @@ endforeach()
foreach(t ${PYBIND11_CROSS_MODULE_GIL_TESTS}) foreach(t ${PYBIND11_CROSS_MODULE_GIL_TESTS})
list(FIND PYBIND11_PYTEST_FILES ${t} i) list(FIND PYBIND11_PYTEST_FILES ${t} i)
if (i GREATER -1) if(i GREATER -1)
list(APPEND test_targets cross_module_gil_utils) list(APPEND test_targets cross_module_gil_utils)
break() break()
endif() endif()
@ -230,7 +233,7 @@ foreach(target ${test_targets})
endif() endif()
if(EIGEN3_FOUND) if(EIGEN3_FOUND)
if (PYBIND11_EIGEN_VIA_TARGET) if(PYBIND11_EIGEN_VIA_TARGET)
target_link_libraries(${target} PRIVATE Eigen3::Eigen) target_link_libraries(${target} PRIVATE Eigen3::Eigen)
else() else()
target_include_directories(${target} PRIVATE ${EIGEN3_INCLUDE_DIR}) target_include_directories(${target} PRIVATE ${EIGEN3_INCLUDE_DIR})
@ -255,8 +258,11 @@ endforeach()
# Make sure pytest is found or produce a fatal error # Make sure pytest is found or produce a fatal error
if(NOT PYBIND11_PYTEST_FOUND) if(NOT PYBIND11_PYTEST_FOUND)
execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import pytest; print(pytest.__version__)" execute_process(
RESULT_VARIABLE pytest_not_found OUTPUT_VARIABLE pytest_version ERROR_QUIET) COMMAND ${PYTHON_EXECUTABLE} -c "import pytest; print(pytest.__version__)"
RESULT_VARIABLE pytest_not_found
OUTPUT_VARIABLE pytest_version
ERROR_QUIET)
if(pytest_not_found) if(pytest_not_found)
message(FATAL_ERROR "Running the tests requires pytest. Please install it manually" message(FATAL_ERROR "Running the tests requires pytest. Please install it manually"
" (try: ${PYTHON_EXECUTABLE} -m pip install pytest)") " (try: ${PYTHON_EXECUTABLE} -m pip install pytest)")
@ -264,16 +270,25 @@ if(NOT PYBIND11_PYTEST_FOUND)
message(FATAL_ERROR "Running the tests requires pytest >= 3.0. Found: ${pytest_version}" message(FATAL_ERROR "Running the tests requires pytest >= 3.0. Found: ${pytest_version}"
"Please update it (try: ${PYTHON_EXECUTABLE} -m pip install -U pytest)") "Please update it (try: ${PYTHON_EXECUTABLE} -m pip install -U pytest)")
endif() endif()
set(PYBIND11_PYTEST_FOUND TRUE CACHE INTERNAL "") set(PYBIND11_PYTEST_FOUND
TRUE
CACHE INTERNAL "")
endif() endif()
# A single command to compile and run the tests # A single command to compile and run the tests
add_custom_target(pytest COMMAND ${PYTHON_EXECUTABLE} -m pytest ${PYBIND11_PYTEST_FILES} add_custom_target(
DEPENDS ${test_targets} WORKING_DIRECTORY ${testdir} USES_TERMINAL) pytest
COMMAND ${PYTHON_EXECUTABLE} -m pytest ${PYBIND11_PYTEST_FILES}
DEPENDS ${test_targets}
WORKING_DIRECTORY ${testdir}
USES_TERMINAL)
if(PYBIND11_TEST_OVERRIDE) if(PYBIND11_TEST_OVERRIDE)
add_custom_command(TARGET pytest POST_BUILD add_custom_command(
COMMAND ${CMAKE_COMMAND} -E echo "Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect") TARGET pytest
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E echo
"Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect")
endif() endif()
# Add a check target to run all the tests, starting with pytest (we add dependencies to this below) # Add a check target to run all the tests, starting with pytest (we add dependencies to this below)
@ -287,11 +302,10 @@ endif()
# Add a post-build comment to show the primary test suite .so size and, if a previous size, compare it: # Add a post-build comment to show the primary test suite .so size and, if a previous size, compare it:
add_custom_command( add_custom_command(
TARGET TARGET pybind11_tests
pybind11_tests POST_BUILD
POST_BUILD COMMAND COMMAND
${PYTHON_EXECUTABLE} ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/../tools/libsize.py
${CMAKE_CURRENT_SOURCE_DIR}/../tools/libsize.py
$<TARGET_FILE:pybind11_tests> $<TARGET_FILE:pybind11_tests>
${CMAKE_CURRENT_BINARY_DIR}/sosize-$<TARGET_FILE_NAME:pybind11_tests>.txt) ${CMAKE_CURRENT_BINARY_DIR}/sosize-$<TARGET_FILE_NAME:pybind11_tests>.txt)

43
tests/test_cmake_build/CMakeLists.txt
View File

@ -1,12 +1,12 @@
add_custom_target(test_cmake_build) add_custom_target(test_cmake_build)
function(pybind11_add_build_test name) function(pybind11_add_build_test name)
cmake_parse_arguments(ARG "INSTALL" "" "" ${ARGN}) cmake_parse_arguments(ARG "INSTALL" "" "" ${ARGN})
set(build_options "-DCMAKE_PREFIX_PATH=${pybind11_BINARY_DIR}/mock_install" set(build_options
"-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" "-DCMAKE_PREFIX_PATH=${pybind11_BINARY_DIR}/mock_install"
"-DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}") "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
"-DPYTHON_EXECUTABLE:FILEPATH=${PYTHON_EXECUTABLE}")
if(CMAKE_CXX_STANDARD) if(CMAKE_CXX_STANDARD)
list(APPEND build_options "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}") list(APPEND build_options "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}")
@ -16,17 +16,25 @@ function(pybind11_add_build_test name)
list(APPEND build_options "-DPYBIND11_PROJECT_DIR=${pybind11_SOURCE_DIR}") list(APPEND build_options "-DPYBIND11_PROJECT_DIR=${pybind11_SOURCE_DIR}")
endif() endif()
add_custom_target(test_${name} ${CMAKE_CTEST_COMMAND} add_custom_target(
--build-and-test "${CMAKE_CURRENT_SOURCE_DIR}/${name}" test_${name}
"${CMAKE_CURRENT_BINARY_DIR}/${name}" ${CMAKE_CTEST_COMMAND}
--build-config Release --build-and-test
"${CMAKE_CURRENT_SOURCE_DIR}/${name}"
"${CMAKE_CURRENT_BINARY_DIR}/${name}"
--build-config
Release
--build-noclean --build-noclean
--build-generator ${CMAKE_GENERATOR} --build-generator
$<$<BOOL:${CMAKE_GENERATOR_PLATFORM}>:--build-generator-platform> ${CMAKE_GENERATOR_PLATFORM} ${CMAKE_GENERATOR}
--build-makeprogram ${CMAKE_MAKE_PROGRAM} $<$<BOOL:${CMAKE_GENERATOR_PLATFORM}>:--build-generator-platform>
--build-target check ${CMAKE_GENERATOR_PLATFORM}
--build-options ${build_options} --build-makeprogram
) ${CMAKE_MAKE_PROGRAM}
--build-target
check
--build-options
${build_options})
if(ARG_INSTALL) if(ARG_INSTALL)
add_dependencies(test_${name} mock_install) add_dependencies(test_${name} mock_install)
endif() endif()
@ -40,10 +48,9 @@ if(NOT ${PYTHON_MODULE_EXTENSION} MATCHES "pypy")
endif() endif()
if(PYBIND11_INSTALL) if(PYBIND11_INSTALL)
add_custom_target(mock_install ${CMAKE_COMMAND} add_custom_target(
"-DCMAKE_INSTALL_PREFIX=${pybind11_BINARY_DIR}/mock_install" mock_install ${CMAKE_COMMAND} "-DCMAKE_INSTALL_PREFIX=${pybind11_BINARY_DIR}/mock_install" -P
-P "${pybind11_BINARY_DIR}/cmake_install.cmake" "${pybind11_BINARY_DIR}/cmake_install.cmake")
)
pybind11_add_build_test(installed_function INSTALL) pybind11_add_build_test(installed_function INSTALL)
pybind11_add_build_test(installed_target INSTALL) pybind11_add_build_test(installed_target INSTALL)

1
tests/test_cmake_build/installed_embed/CMakeLists.txt
View File

@ -8,7 +8,6 @@ message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
add_executable(test_cmake_build ../embed.cpp) add_executable(test_cmake_build ../embed.cpp)
target_link_libraries(test_cmake_build PRIVATE pybind11::embed) target_link_libraries(test_cmake_build PRIVATE pybind11::embed)
# Do not treat includes from IMPORTED target as SYSTEM (Python headers in pybind11::embed). # Do not treat includes from IMPORTED target as SYSTEM (Python headers in pybind11::embed).
# This may be needed to resolve header conflicts, e.g. between Python release and debug headers. # This may be needed to resolve header conflicts, e.g. between Python release and debug headers.
set_target_properties(test_cmake_build PROPERTIES NO_SYSTEM_FROM_IMPORTED ON) set_target_properties(test_cmake_build PROPERTIES NO_SYSTEM_FROM_IMPORTED ON)

11
tests/test_cmake_build/installed_function/CMakeLists.txt
View File

@ -8,5 +8,12 @@ message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
pybind11_add_module(test_cmake_build SHARED NO_EXTRAS ../main.cpp) pybind11_add_module(test_cmake_build SHARED NO_EXTRAS ../main.cpp)
add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build> add_custom_target(
${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME}) check
${CMAKE_COMMAND}
-E
env
PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
${PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/../test.py
${PROJECT_NAME})

11
tests/test_cmake_build/installed_target/CMakeLists.txt
View File

@ -18,5 +18,12 @@ set_target_properties(test_cmake_build PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX
# This may be needed to resolve header conflicts, e.g. between Python release and debug headers. # This may be needed to resolve header conflicts, e.g. between Python release and debug headers.
set_target_properties(test_cmake_build PROPERTIES NO_SYSTEM_FROM_IMPORTED ON) set_target_properties(test_cmake_build PROPERTIES NO_SYSTEM_FROM_IMPORTED ON)
add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build> add_custom_target(
${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME}) check
${CMAKE_COMMAND}
-E
env
PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
${PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/../test.py
${PROJECT_NAME})

18
tests/test_cmake_build/subdirectory_embed/CMakeLists.txt
View File

@ -1,7 +1,9 @@
cmake_minimum_required(VERSION 3.7) cmake_minimum_required(VERSION 3.7)
project(test_subdirectory_embed CXX) project(test_subdirectory_embed CXX)
set(PYBIND11_INSTALL ON CACHE BOOL "") set(PYBIND11_INSTALL
ON
CACHE BOOL "")
set(PYBIND11_EXPORT_NAME test_export) set(PYBIND11_EXPORT_NAME test_export)
add_subdirectory(${PYBIND11_PROJECT_DIR} pybind11) add_subdirectory(${PYBIND11_PROJECT_DIR} pybind11)
@ -16,10 +18,10 @@ add_custom_target(check $<TARGET_FILE:test_cmake_build> ${PROJECT_SOURCE_DIR}/..
add_library(test_embed_lib ../embed.cpp) add_library(test_embed_lib ../embed.cpp)
target_link_libraries(test_embed_lib PRIVATE pybind11::embed) target_link_libraries(test_embed_lib PRIVATE pybind11::embed)
install(TARGETS test_embed_lib install(
EXPORT test_export TARGETS test_embed_lib
ARCHIVE DESTINATION bin EXPORT test_export
LIBRARY DESTINATION lib ARCHIVE DESTINATION bin
RUNTIME DESTINATION lib) LIBRARY DESTINATION lib
install(EXPORT test_export RUNTIME DESTINATION lib)
DESTINATION lib/cmake/test_export/test_export-Targets.cmake) install(EXPORT test_export DESTINATION lib/cmake/test_export/test_export-Targets.cmake)

11
tests/test_cmake_build/subdirectory_function/CMakeLists.txt
View File

@ -4,5 +4,12 @@ project(test_subdirectory_module CXX)
add_subdirectory(${PYBIND11_PROJECT_DIR} pybind11) add_subdirectory(${PYBIND11_PROJECT_DIR} pybind11)
pybind11_add_module(test_cmake_build THIN_LTO ../main.cpp) pybind11_add_module(test_cmake_build THIN_LTO ../main.cpp)
add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build> add_custom_target(
${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME}) check
${CMAKE_COMMAND}
-E
env
PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
${PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/../test.py
${PROJECT_NAME})

11
tests/test_cmake_build/subdirectory_target/CMakeLists.txt
View File

@ -11,5 +11,12 @@ target_link_libraries(test_cmake_build PRIVATE pybind11::module)
set_target_properties(test_cmake_build PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}" set_target_properties(test_cmake_build PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
SUFFIX "${PYTHON_MODULE_EXTENSION}") SUFFIX "${PYTHON_MODULE_EXTENSION}")
add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build> add_custom_target(
${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME}) check
${CMAKE_COMMAND}
-E
env
PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
${PYTHON_EXECUTABLE}
${PROJECT_SOURCE_DIR}/../test.py
${PROJECT_NAME})

19
tests/test_embed/CMakeLists.txt
View File

@ -1,5 +1,5 @@
if(${PYTHON_MODULE_EXTENSION} MATCHES "pypy") if(${PYTHON_MODULE_EXTENSION} MATCHES "pypy")
add_custom_target(cpptest) # Dummy target on PyPy. Embedding is not supported. add_custom_target(cpptest) # Dummy target on PyPy. Embedding is not supported.
set(_suppress_unused_variable_warning "${DOWNLOAD_CATCH}") set(_suppress_unused_variable_warning "${DOWNLOAD_CATCH}")
return() return()
endif() endif()
@ -13,10 +13,7 @@ else()
return() return()
endif() endif()
add_executable(test_embed add_executable(test_embed catch.cpp test_interpreter.cpp)
catch.cpp
test_interpreter.cpp
)
target_include_directories(test_embed PRIVATE "${CATCH_INCLUDE_DIR}") target_include_directories(test_embed PRIVATE "${CATCH_INCLUDE_DIR}")
pybind11_enable_warnings(test_embed) pybind11_enable_warnings(test_embed)
@ -25,14 +22,18 @@ target_link_libraries(test_embed PRIVATE pybind11::embed)
find_package(Threads REQUIRED) find_package(Threads REQUIRED)
target_link_libraries(test_embed PUBLIC Threads::Threads) target_link_libraries(test_embed PUBLIC Threads::Threads)
add_custom_target(cpptest COMMAND "$<TARGET_FILE:test_embed>" add_custom_target(
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") cpptest
COMMAND "$<TARGET_FILE:test_embed>"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
pybind11_add_module(external_module THIN_LTO external_module.cpp) pybind11_add_module(external_module THIN_LTO external_module.cpp)
set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY
"${CMAKE_CURRENT_SOURCE_DIR}")
foreach(config ${CMAKE_CONFIGURATION_TYPES}) foreach(config ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${config} config) string(TOUPPER ${config} config)
set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${config} "${CMAKE_CURRENT_SOURCE_DIR}") set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${config}
"${CMAKE_CURRENT_SOURCE_DIR}")
endforeach() endforeach()
add_dependencies(cpptest external_module) add_dependencies(cpptest external_module)

18
tools/FindCatch.cmake
View File

@ -19,9 +19,14 @@ endif()
# Extract the version number from catch.hpp # Extract the version number from catch.hpp
function(_get_catch_version) function(_get_catch_version)
file(STRINGS "${CATCH_INCLUDE_DIR}/catch.hpp" version_line REGEX "Catch v.*" LIMIT_COUNT 1) file(
STRINGS "${CATCH_INCLUDE_DIR}/catch.hpp" version_line
REGEX "Catch v.*"
LIMIT_COUNT 1)
if(version_line MATCHES "Catch v([0-9]+)\\.([0-9]+)\\.([0-9]+)") if(version_line MATCHES "Catch v([0-9]+)\\.([0-9]+)\\.([0-9]+)")
set(CATCH_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}" PARENT_SCOPE) set(CATCH_VERSION
"${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}"
PARENT_SCOPE)
endif() endif()
endfunction() endfunction()
@ -34,11 +39,16 @@ function(_download_catch version destination_dir)
if(error) if(error)
message(FATAL_ERROR "Could not download ${url}") message(FATAL_ERROR "Could not download ${url}")
endif() endif()
set(CATCH_INCLUDE_DIR "${destination_dir}" CACHE INTERNAL "") set(CATCH_INCLUDE_DIR
"${destination_dir}"
CACHE INTERNAL "")
endfunction() endfunction()
# Look for catch locally # Look for catch locally
find_path(CATCH_INCLUDE_DIR NAMES catch.hpp PATH_SUFFIXES catch2) find_path(
CATCH_INCLUDE_DIR
NAMES catch.hpp
PATH_SUFFIXES catch2)
if(CATCH_INCLUDE_DIR) if(CATCH_INCLUDE_DIR)
_get_catch_version() _get_catch_version()
endif() endif()

27
tools/FindEigen3.cmake
View File

@ -26,17 +26,21 @@ if(NOT Eigen3_FIND_VERSION)
set(Eigen3_FIND_VERSION_PATCH 0) set(Eigen3_FIND_VERSION_PATCH 0)
endif(NOT Eigen3_FIND_VERSION_PATCH) endif(NOT Eigen3_FIND_VERSION_PATCH)
set(Eigen3_FIND_VERSION "${Eigen3_FIND_VERSION_MAJOR}.${Eigen3_FIND_VERSION_MINOR}.${Eigen3_FIND_VERSION_PATCH}") set(Eigen3_FIND_VERSION
"${Eigen3_FIND_VERSION_MAJOR}.${Eigen3_FIND_VERSION_MINOR}.${Eigen3_FIND_VERSION_PATCH}")
endif(NOT Eigen3_FIND_VERSION) endif(NOT Eigen3_FIND_VERSION)
macro(_eigen3_check_version) macro(_eigen3_check_version)
file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header) file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header)
string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}") string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match
"${_eigen3_version_header}")
set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}") set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}")
string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}") string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match
"${_eigen3_version_header}")
set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}") set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}")
string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}") string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match
"${_eigen3_version_header}")
set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}") set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}")
set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION}) set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION})
@ -53,20 +57,19 @@ macro(_eigen3_check_version)
endif(NOT EIGEN3_VERSION_OK) endif(NOT EIGEN3_VERSION_OK)
endmacro(_eigen3_check_version) endmacro(_eigen3_check_version)
if (EIGEN3_INCLUDE_DIR) if(EIGEN3_INCLUDE_DIR)
# in cache already # in cache already
_eigen3_check_version() _eigen3_check_version()
set(EIGEN3_FOUND ${EIGEN3_VERSION_OK}) set(EIGEN3_FOUND ${EIGEN3_VERSION_OK})
else (EIGEN3_INCLUDE_DIR) else(EIGEN3_INCLUDE_DIR)
find_path(EIGEN3_INCLUDE_DIR NAMES signature_of_eigen3_matrix_library find_path(
PATHS EIGEN3_INCLUDE_DIR
${CMAKE_INSTALL_PREFIX}/include NAMES signature_of_eigen3_matrix_library
${KDE4_INCLUDE_DIR} PATHS ${CMAKE_INSTALL_PREFIX}/include ${KDE4_INCLUDE_DIR}
PATH_SUFFIXES eigen3 eigen PATH_SUFFIXES eigen3 eigen)
)
if(EIGEN3_INCLUDE_DIR) if(EIGEN3_INCLUDE_DIR)
_eigen3_check_version() _eigen3_check_version()

162
tools/FindPythonLibsNew.cmake
View File

@ -52,23 +52,23 @@
# Checking for the extension makes sure that `LibsNew` was found and not just `Libs`. # Checking for the extension makes sure that `LibsNew` was found and not just `Libs`.
if(PYTHONLIBS_FOUND AND PYTHON_MODULE_EXTENSION) if(PYTHONLIBS_FOUND AND PYTHON_MODULE_EXTENSION)
return() return()
endif() endif()
# Use the Python interpreter to find the libs. # Use the Python interpreter to find the libs.
if(NOT PythonLibsNew_FIND_VERSION) if(NOT PythonLibsNew_FIND_VERSION)
set(PythonLibsNew_FIND_VERSION "") set(PythonLibsNew_FIND_VERSION "")
endif() endif()
if(PythonLibsNew_FIND_REQUIRED) if(PythonLibsNew_FIND_REQUIRED)
find_package(PythonInterp ${PythonLibsNew_FIND_VERSION} REQUIRED) find_package(PythonInterp ${PythonLibsNew_FIND_VERSION} REQUIRED)
else() else()
find_package(PythonInterp ${PythonLibsNew_FIND_VERSION}) find_package(PythonInterp ${PythonLibsNew_FIND_VERSION})
endif() endif()
if(NOT PYTHONINTERP_FOUND) if(NOT PYTHONINTERP_FOUND)
set(PYTHONLIBS_FOUND FALSE) set(PYTHONLIBS_FOUND FALSE)
set(PythonLibsNew_FOUND FALSE) set(PythonLibsNew_FOUND FALSE)
return() return()
endif() endif()
# According to http://stackoverflow.com/questions/646518/python-how-to-detect-debug-interpreter # According to http://stackoverflow.com/questions/646518/python-how-to-detect-debug-interpreter
@ -77,8 +77,9 @@ endif()
# #
# The library suffix is from the config var LDVERSION sometimes, otherwise # The library suffix is from the config var LDVERSION sometimes, otherwise
# VERSION. VERSION will typically be like "2.7" on unix, and "27" on windows. # VERSION. VERSION will typically be like "2.7" on unix, and "27" on windows.
execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c" execute_process(
"from distutils import sysconfig as s;import sys;import struct; COMMAND
"${PYTHON_EXECUTABLE}" "-c" "from distutils import sysconfig as s;import sys;import struct;
print('.'.join(str(v) for v in sys.version_info)); print('.'.join(str(v) for v in sys.version_info));
print(sys.prefix); print(sys.prefix);
print(s.get_python_inc(plat_specific=True)); print(s.get_python_inc(plat_specific=True));
@ -90,23 +91,22 @@ print(s.get_config_var('LDVERSION') or s.get_config_var('VERSION'));
print(s.get_config_var('LIBDIR') or ''); print(s.get_config_var('LIBDIR') or '');
print(s.get_config_var('MULTIARCH') or ''); print(s.get_config_var('MULTIARCH') or '');
" "
RESULT_VARIABLE _PYTHON_SUCCESS RESULT_VARIABLE _PYTHON_SUCCESS
OUTPUT_VARIABLE _PYTHON_VALUES OUTPUT_VARIABLE _PYTHON_VALUES
ERROR_VARIABLE _PYTHON_ERROR_VALUE) ERROR_VARIABLE _PYTHON_ERROR_VALUE)
if(NOT _PYTHON_SUCCESS MATCHES 0) if(NOT _PYTHON_SUCCESS MATCHES 0)
if(PythonLibsNew_FIND_REQUIRED) if(PythonLibsNew_FIND_REQUIRED)
message(FATAL_ERROR message(FATAL_ERROR "Python config failure:\n${_PYTHON_ERROR_VALUE}")
"Python config failure:\n${_PYTHON_ERROR_VALUE}") endif()
endif() set(PYTHONLIBS_FOUND FALSE)
set(PYTHONLIBS_FOUND FALSE) set(PythonLibsNew_FOUND FALSE)
set(PythonLibsNew_FOUND FALSE) return()
return()
endif() endif()
# Convert the process output into a list # Convert the process output into a list
if(WIN32) if(WIN32)
string(REGEX REPLACE "\\\\" "/" _PYTHON_VALUES ${_PYTHON_VALUES}) string(REGEX REPLACE "\\\\" "/" _PYTHON_VALUES ${_PYTHON_VALUES})
endif() endif()
string(REGEX REPLACE ";" "\\\\;" _PYTHON_VALUES ${_PYTHON_VALUES}) string(REGEX REPLACE ";" "\\\\;" _PYTHON_VALUES ${_PYTHON_VALUES})
string(REGEX REPLACE "\n" ";" _PYTHON_VALUES ${_PYTHON_VALUES}) string(REGEX REPLACE "\n" ";" _PYTHON_VALUES ${_PYTHON_VALUES})
@ -124,16 +124,15 @@ list(GET _PYTHON_VALUES 9 PYTHON_MULTIARCH)
# Make sure the Python has the same pointer-size as the chosen compiler # Make sure the Python has the same pointer-size as the chosen compiler
# Skip if CMAKE_SIZEOF_VOID_P is not defined # Skip if CMAKE_SIZEOF_VOID_P is not defined
if(CMAKE_SIZEOF_VOID_P AND (NOT "${PYTHON_SIZEOF_VOID_P}" STREQUAL "${CMAKE_SIZEOF_VOID_P}")) if(CMAKE_SIZEOF_VOID_P AND (NOT "${PYTHON_SIZEOF_VOID_P}" STREQUAL "${CMAKE_SIZEOF_VOID_P}"))
if(PythonLibsNew_FIND_REQUIRED) if(PythonLibsNew_FIND_REQUIRED)
math(EXPR _PYTHON_BITS "${PYTHON_SIZEOF_VOID_P} * 8") math(EXPR _PYTHON_BITS "${PYTHON_SIZEOF_VOID_P} * 8")
math(EXPR _CMAKE_BITS "${CMAKE_SIZEOF_VOID_P} * 8") math(EXPR _CMAKE_BITS "${CMAKE_SIZEOF_VOID_P} * 8")
message(FATAL_ERROR message(FATAL_ERROR "Python config failure: Python is ${_PYTHON_BITS}-bit, "
"Python config failure: Python is ${_PYTHON_BITS}-bit, " "chosen compiler is ${_CMAKE_BITS}-bit")
"chosen compiler is ${_CMAKE_BITS}-bit") endif()
endif() set(PYTHONLIBS_FOUND FALSE)
set(PYTHONLIBS_FOUND FALSE) set(PythonLibsNew_FOUND FALSE)
set(PythonLibsNew_FOUND FALSE) return()
return()
endif() endif()
# The built-in FindPython didn't always give the version numbers # The built-in FindPython didn't always give the version numbers
@ -148,79 +147,76 @@ string(REGEX REPLACE "\\\\" "/" PYTHON_INCLUDE_DIR "${PYTHON_INCLUDE_DIR}")
string(REGEX REPLACE "\\\\" "/" PYTHON_SITE_PACKAGES "${PYTHON_SITE_PACKAGES}") string(REGEX REPLACE "\\\\" "/" PYTHON_SITE_PACKAGES "${PYTHON_SITE_PACKAGES}")
if(CMAKE_HOST_WIN32) if(CMAKE_HOST_WIN32)
set(PYTHON_LIBRARY set(PYTHON_LIBRARY "${PYTHON_PREFIX}/libs/python${PYTHON_LIBRARY_SUFFIX}.lib")
"${PYTHON_PREFIX}/libs/python${PYTHON_LIBRARY_SUFFIX}.lib")
# when run in a venv, PYTHON_PREFIX points to it. But the libraries remain in the # when run in a venv, PYTHON_PREFIX points to it. But the libraries remain in the
# original python installation. They may be found relative to PYTHON_INCLUDE_DIR. # original python installation. They may be found relative to PYTHON_INCLUDE_DIR.
if(NOT EXISTS "${PYTHON_LIBRARY}") if(NOT EXISTS "${PYTHON_LIBRARY}")
get_filename_component(_PYTHON_ROOT ${PYTHON_INCLUDE_DIR} DIRECTORY) get_filename_component(_PYTHON_ROOT ${PYTHON_INCLUDE_DIR} DIRECTORY)
set(PYTHON_LIBRARY set(PYTHON_LIBRARY "${_PYTHON_ROOT}/libs/python${PYTHON_LIBRARY_SUFFIX}.lib")
"${_PYTHON_ROOT}/libs/python${PYTHON_LIBRARY_SUFFIX}.lib") endif()
endif()
# if we are in MSYS & MINGW, and we didn't find windows python lib, look for system python lib # if we are in MSYS & MINGW, and we didn't find windows python lib, look for system python lib
if(DEFINED ENV{MSYSTEM} AND MINGW AND NOT EXISTS "${PYTHON_LIBRARY}") if(DEFINED ENV{MSYSTEM}
if(PYTHON_MULTIARCH) AND MINGW
set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}/${PYTHON_MULTIARCH}" "${PYTHON_LIBDIR}") AND NOT EXISTS "${PYTHON_LIBRARY}")
else() if(PYTHON_MULTIARCH)
set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}") set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}/${PYTHON_MULTIARCH}" "${PYTHON_LIBDIR}")
endif() else()
unset(PYTHON_LIBRARY) set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}")
find_library(PYTHON_LIBRARY
NAMES "python${PYTHON_LIBRARY_SUFFIX}"
PATHS ${_PYTHON_LIBS_SEARCH}
NO_DEFAULT_PATH)
endif() endif()
unset(PYTHON_LIBRARY)
find_library(
PYTHON_LIBRARY
NAMES "python${PYTHON_LIBRARY_SUFFIX}"
PATHS ${_PYTHON_LIBS_SEARCH}
NO_DEFAULT_PATH)
endif()
# raise an error if the python libs are still not found. # raise an error if the python libs are still not found.
if(NOT EXISTS "${PYTHON_LIBRARY}") if(NOT EXISTS "${PYTHON_LIBRARY}")
message(FATAL_ERROR "Python libraries not found") message(FATAL_ERROR "Python libraries not found")
endif() endif()
else() else()
if(PYTHON_MULTIARCH) if(PYTHON_MULTIARCH)
set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}/${PYTHON_MULTIARCH}" "${PYTHON_LIBDIR}") set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}/${PYTHON_MULTIARCH}" "${PYTHON_LIBDIR}")
else() else()
set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}") set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}")
endif() endif()
#message(STATUS "Searching for Python libs in ${_PYTHON_LIBS_SEARCH}") #message(STATUS "Searching for Python libs in ${_PYTHON_LIBS_SEARCH}")
# Probably this needs to be more involved. It would be nice if the config # Probably this needs to be more involved. It would be nice if the config
# information the python interpreter itself gave us were more complete. # information the python interpreter itself gave us were more complete.
find_library(PYTHON_LIBRARY find_library(
NAMES "python${PYTHON_LIBRARY_SUFFIX}" PYTHON_LIBRARY
PATHS ${_PYTHON_LIBS_SEARCH} NAMES "python${PYTHON_LIBRARY_SUFFIX}"
NO_DEFAULT_PATH) PATHS ${_PYTHON_LIBS_SEARCH} NO_DEFAULT_PATH)
# If all else fails, just set the name/version and let the linker figure out the path. # If all else fails, just set the name/version and let the linker figure out the path.
if(NOT PYTHON_LIBRARY) if(NOT PYTHON_LIBRARY)
set(PYTHON_LIBRARY python${PYTHON_LIBRARY_SUFFIX}) set(PYTHON_LIBRARY python${PYTHON_LIBRARY_SUFFIX})
endif() endif()
endif() endif()
MARK_AS_ADVANCED( mark_as_advanced(PYTHON_LIBRARY PYTHON_INCLUDE_DIR)
PYTHON_LIBRARY
PYTHON_INCLUDE_DIR
)
# We use PYTHON_INCLUDE_DIR, PYTHON_LIBRARY and PYTHON_DEBUG_LIBRARY for the # We use PYTHON_INCLUDE_DIR, PYTHON_LIBRARY and PYTHON_DEBUG_LIBRARY for the
# cache entries because they are meant to specify the location of a single # cache entries because they are meant to specify the location of a single
# library. We now set the variables listed by the documentation for this # library. We now set the variables listed by the documentation for this
# module. # module.
SET(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}") set(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}")
SET(PYTHON_LIBRARIES "${PYTHON_LIBRARY}") set(PYTHON_LIBRARIES "${PYTHON_LIBRARY}")
if(NOT PYTHON_DEBUG_LIBRARY) if(NOT PYTHON_DEBUG_LIBRARY)
SET(PYTHON_DEBUG_LIBRARY "") set(PYTHON_DEBUG_LIBRARY "")
endif() endif()
SET(PYTHON_DEBUG_LIBRARIES "${PYTHON_DEBUG_LIBRARY}") set(PYTHON_DEBUG_LIBRARIES "${PYTHON_DEBUG_LIBRARY}")
find_package_message(PYTHON find_package_message(PYTHON "Found PythonLibs: ${PYTHON_LIBRARY}"
"Found PythonLibs: ${PYTHON_LIBRARY}" "${PYTHON_EXECUTABLE}${PYTHON_VERSION_STRING}")
"${PYTHON_EXECUTABLE}${PYTHON_VERSION_STRING}")
set(PYTHONLIBS_FOUND TRUE) set(PYTHONLIBS_FOUND TRUE)
set(PythonLibsNew_FOUND TRUE) set(PythonLibsNew_FOUND TRUE)
if(NOT PYTHON_MODULE_PREFIX) if(NOT PYTHON_MODULE_PREFIX)
SET(PYTHON_MODULE_PREFIX "") set(PYTHON_MODULE_PREFIX "")
endif() endif()

135
tools/pybind11Tools.cmake
View File

@ -10,18 +10,22 @@ cmake_minimum_required(VERSION 3.7)
# VERSION 3.7...3.18, but some versions of VS have a patched CMake 3.11 # VERSION 3.7...3.18, but some versions of VS have a patched CMake 3.11
# that do not work properly with this syntax, so using the following workaround: # that do not work properly with this syntax, so using the following workaround:
if(${CMAKE_VERSION} VERSION_LESS 3.18) if(${CMAKE_VERSION} VERSION_LESS 3.18)
cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}) cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
else() else()
cmake_policy(VERSION 3.18) cmake_policy(VERSION 3.18)
endif() endif()
# Add a CMake parameter for choosing a desired Python version # Add a CMake parameter for choosing a desired Python version
if(NOT PYBIND11_PYTHON_VERSION) if(NOT PYBIND11_PYTHON_VERSION)
set(PYBIND11_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling modules") set(PYBIND11_PYTHON_VERSION
""
CACHE STRING "Python version to use for compiling modules")
endif() endif()
# A user can set versions manually too # A user can set versions manually too
set(Python_ADDITIONAL_VERSIONS "3.9;3.8;3.7;3.6;3.5;3.4" CACHE INTERNAL "") set(Python_ADDITIONAL_VERSIONS
"3.9;3.8;3.7;3.6;3.5;3.4"
CACHE INTERNAL "")
find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} REQUIRED) find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} REQUIRED)
include(CheckCXXCompilerFlag) include(CheckCXXCompilerFlag)
@ -29,76 +33,80 @@ include(CMakeParseArguments)
# Warn or error if old variable name used # Warn or error if old variable name used
if(PYBIND11_CPP_STANDARD) if(PYBIND11_CPP_STANDARD)
if(NOT CMAKE_CXX_STANDARD) if(NOT CMAKE_CXX_STANDARD)
string(REGEX MATCH string(REGEX MATCH [=[..^]=] VAL "${PYBIND11_CPP_STANDARD}")
[=[..^]=] set(supported_standards 11 14 17 20)
VAL if("${VAL}" IN_LIST supported_standards)
"${PYBIND11_CPP_STANDARD}") message(WARNING "USE -DCMAKE_CXX_STANDARD=${VAL} instead of PYBIND11_PYTHON_VERSION")
set(supported_standards 11 14 17 20) set(CMAKE_CXX_STANDARD ${VAL})
if("${VAL}" IN_LIST supported_standards) else()
message(WARNING "USE -DCMAKE_CXX_STANDARD=${VAL} instead of PYBIND11_PYTHON_VERSION") message(FATAL_ERROR "PYBIND11_CPP_STANDARD should be replaced with CMAKE_CXX_STANDARD")
set(CMAKE_CXX_STANDARD ${VAL})
else()
message(FATAL_ERROR "PYBIND11_CPP_STANDARD should be replaced with CMAKE_CXX_STANDARD")
endif()
endif() endif()
endif()
endif() endif()
# Checks whether the given CXX/linker flags can compile and link a cxx file. cxxflags and # Checks whether the given CXX/linker flags can compile and link a cxx file. cxxflags and
# linkerflags are lists of flags to use. The result variable is a unique variable name for each set # linkerflags are lists of flags to use. The result variable is a unique variable name for each set
# of flags: the compilation result will be cached base on the result variable. If the flags work, # of flags: the compilation result will be cached base on the result variable. If the flags work,
# sets them in cxxflags_out/linkerflags_out internal cache variables (in addition to ${result}). # sets them in cxxflags_out/linkerflags_out internal cache variables (in addition to ${result}).
function(_pybind11_return_if_cxx_and_linker_flags_work result cxxflags linkerflags cxxflags_out linkerflags_out) function(_pybind11_return_if_cxx_and_linker_flags_work result cxxflags linkerflags cxxflags_out
linkerflags_out)
set(CMAKE_REQUIRED_LIBRARIES ${linkerflags}) set(CMAKE_REQUIRED_LIBRARIES ${linkerflags})
check_cxx_compiler_flag("${cxxflags}" ${result}) check_cxx_compiler_flag("${cxxflags}" ${result})
if (${result}) if(${result})
set(${cxxflags_out} "${cxxflags}" CACHE INTERNAL "" FORCE) set(${cxxflags_out}
set(${linkerflags_out} "${linkerflags}" CACHE INTERNAL "" FORCE) "${cxxflags}"
CACHE INTERNAL "" FORCE)
set(${linkerflags_out}
"${linkerflags}"
CACHE INTERNAL "" FORCE)
endif() endif()
endfunction() endfunction()
# Internal: find the appropriate link time optimization flags for this compiler # Internal: find the appropriate link time optimization flags for this compiler
function(_pybind11_add_lto_flags target_name prefer_thin_lto) function(_pybind11_add_lto_flags target_name prefer_thin_lto)
if (NOT DEFINED PYBIND11_LTO_CXX_FLAGS) if(NOT DEFINED PYBIND11_LTO_CXX_FLAGS)
set(PYBIND11_LTO_CXX_FLAGS "" CACHE INTERNAL "") set(PYBIND11_LTO_CXX_FLAGS
set(PYBIND11_LTO_LINKER_FLAGS "" CACHE INTERNAL "") ""
CACHE INTERNAL "")
set(PYBIND11_LTO_LINKER_FLAGS
""
CACHE INTERNAL "")
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang") if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
set(cxx_append "") set(cxx_append "")
set(linker_append "") set(linker_append "")
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT APPLE) if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT APPLE)
# Clang Gold plugin does not support -Os; append -O3 to MinSizeRel builds to override it # Clang Gold plugin does not support -Os; append -O3 to MinSizeRel builds to override it
set(linker_append ";$<$<CONFIG:MinSizeRel>:-O3>") set(linker_append ";$<$<CONFIG:MinSizeRel>:-O3>")
elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU") elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
set(cxx_append ";-fno-fat-lto-objects") set(cxx_append ";-fno-fat-lto-objects")
endif() endif()
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND prefer_thin_lto) if(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND prefer_thin_lto)
_pybind11_return_if_cxx_and_linker_flags_work(HAS_FLTO_THIN _pybind11_return_if_cxx_and_linker_flags_work(
"-flto=thin${cxx_append}" "-flto=thin${linker_append}" HAS_FLTO_THIN "-flto=thin${cxx_append}" "-flto=thin${linker_append}"
PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS) PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
endif() endif()
if (NOT HAS_FLTO_THIN) if(NOT HAS_FLTO_THIN)
_pybind11_return_if_cxx_and_linker_flags_work(HAS_FLTO _pybind11_return_if_cxx_and_linker_flags_work(
"-flto${cxx_append}" "-flto${linker_append}" HAS_FLTO "-flto${cxx_append}" "-flto${linker_append}" PYBIND11_LTO_CXX_FLAGS
PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS) PYBIND11_LTO_LINKER_FLAGS)
endif() endif()
elseif (CMAKE_CXX_COMPILER_ID MATCHES "Intel") elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
# Intel equivalent to LTO is called IPO # Intel equivalent to LTO is called IPO
_pybind11_return_if_cxx_and_linker_flags_work(HAS_INTEL_IPO _pybind11_return_if_cxx_and_linker_flags_work(
"-ipo" "-ipo" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS) HAS_INTEL_IPO "-ipo" "-ipo" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
elseif(MSVC) elseif(MSVC)
# cmake only interprets libraries as linker flags when they start with a - (otherwise it # cmake only interprets libraries as linker flags when they start with a - (otherwise it
# converts /LTCG to \LTCG as if it was a Windows path). Luckily MSVC supports passing flags # converts /LTCG to \LTCG as if it was a Windows path). Luckily MSVC supports passing flags
# with - instead of /, even if it is a bit non-standard: # with - instead of /, even if it is a bit non-standard:
_pybind11_return_if_cxx_and_linker_flags_work(HAS_MSVC_GL_LTCG _pybind11_return_if_cxx_and_linker_flags_work(
"/GL" "-LTCG" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS) HAS_MSVC_GL_LTCG "/GL" "-LTCG" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
endif() endif()
if (PYBIND11_LTO_CXX_FLAGS) if(PYBIND11_LTO_CXX_FLAGS)
message(STATUS "LTO enabled") message(STATUS "LTO enabled")
else() else()
message(STATUS "LTO disabled (not supported by the compiler and/or linker)") message(STATUS "LTO disabled (not supported by the compiler and/or linker)")
@ -106,12 +114,13 @@ function(_pybind11_add_lto_flags target_name prefer_thin_lto)
endif() endif()
# Enable LTO flags if found, except for Debug builds # Enable LTO flags if found, except for Debug builds
if (PYBIND11_LTO_CXX_FLAGS) if(PYBIND11_LTO_CXX_FLAGS)
set(not_debug "$<NOT:$<CONFIG:Debug>>") set(not_debug "$<NOT:$<CONFIG:Debug>>")
set(cxx_lang "$<COMPILE_LANGUAGE:CXX>") set(cxx_lang "$<COMPILE_LANGUAGE:CXX>")
target_compile_options(${target_name} PRIVATE "$<$<AND:${not_debug},${cxx_lang}>:${PYBIND11_LTO_CXX_FLAGS}>") target_compile_options(${target_name}
PRIVATE "$<$<AND:${not_debug},${cxx_lang}>:${PYBIND11_LTO_CXX_FLAGS}>")
endif() endif()
if (PYBIND11_LTO_LINKER_FLAGS) if(PYBIND11_LTO_LINKER_FLAGS)
target_link_libraries(${target_name} PRIVATE "$<${not_debug}:${PYBIND11_LTO_LINKER_FLAGS}>") target_link_libraries(${target_name} PRIVATE "$<${not_debug}:${PYBIND11_LTO_LINKER_FLAGS}>")
endif() endif()
endfunction() endfunction()
@ -143,7 +152,10 @@ function(pybind11_add_module target_name)
target_link_libraries(${target_name} PRIVATE pybind11::module) target_link_libraries(${target_name} PRIVATE pybind11::module)
if(ARG_SYSTEM) if(ARG_SYSTEM)
message(STATUS "Warning: this does not have an effect - use NO_SYSTEM_FROM_IMPORTED if using imported targets") message(
STATUS
"Warning: this does not have an effect - use NO_SYSTEM_FROM_IMPORTED if using imported targets"
)
endif() endif()
# Python debug libraries expose slightly different objects before 3.8 # Python debug libraries expose slightly different objects before 3.8
@ -165,35 +177,33 @@ function(pybind11_add_module target_name)
set_target_properties(${target_name} PROPERTIES CXX_VISIBILITY_PRESET "hidden") set_target_properties(${target_name} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
set_target_properties(${target_name} PROPERTIES CUDA_VISIBILITY_PRESET "hidden") set_target_properties(${target_name} PROPERTIES CUDA_VISIBILITY_PRESET "hidden")
if(ARG_NO_EXTRAS) if(ARG_NO_EXTRAS)
return() return()
endif() endif()
if(CMAKE_VERSION VERSION_LESS 3.9 OR PYBIND11_CLASSIC_LTO) if(CMAKE_VERSION VERSION_LESS 3.9 OR PYBIND11_CLASSIC_LTO)
_pybind11_add_lto_flags(${target_name} ${ARG_THIN_LTO}) _pybind11_add_lto_flags(${target_name} ${ARG_THIN_LTO})
else() else()
include(CheckIPOSupported) include(CheckIPOSupported)
check_ipo_supported(RESULT supported OUTPUT error) check_ipo_supported(RESULT supported OUTPUT error)
if(supported) if(supported)
set_property( set_property(TARGET ${target_name} PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
TARGET endif()
${target_name}
PROPERTY
INTERPROCEDURAL_OPTIMIZATION TRUE
)
endif()
endif() endif()
if (NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug|RelWithDebInfo) if(NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug|RelWithDebInfo)
# Strip unnecessary sections of the binary on Linux/Mac OS # Strip unnecessary sections of the binary on Linux/Mac OS
if(CMAKE_STRIP) if(CMAKE_STRIP)
if(APPLE) if(APPLE)
add_custom_command(TARGET ${target_name} POST_BUILD add_custom_command(
COMMAND ${CMAKE_STRIP} -x $<TARGET_FILE:${target_name}>) TARGET ${target_name}
POST_BUILD
COMMAND ${CMAKE_STRIP} -x $<TARGET_FILE:${target_name}>)
else() else()
add_custom_command(TARGET ${target_name} POST_BUILD add_custom_command(
COMMAND ${CMAKE_STRIP} $<TARGET_FILE:${target_name}>) TARGET ${target_name}
POST_BUILD
COMMAND ${CMAKE_STRIP} $<TARGET_FILE:${target_name}>)
endif() endif()
endif() endif()
endif() endif()
@ -209,7 +219,8 @@ function(pybind11_add_module target_name)
# instance, projects that include other types of source files like CUDA # instance, projects that include other types of source files like CUDA
# .cu files don't get these options propagated to nvcc since that would # .cu files don't get these options propagated to nvcc since that would
# cause the build to fail. # cause the build to fail.
target_compile_options(${target_name} PRIVATE $<$<NOT:$<CONFIG:Debug>>:$<$<COMPILE_LANGUAGE:CXX>:/MP>>) target_compile_options(${target_name}
PRIVATE $<$<NOT:$<CONFIG:Debug>>:$<$<COMPILE_LANGUAGE:CXX>:/MP>>)
endif() endif()
endif() endif()
endfunction() endfunction()