cmake_minimum_required(VERSION 3.15)
list(APPEND CMAKE_MESSAGE_CONTEXT "Corrosion")
message(DEBUG "Using Corrosion ${Corrosion_VERSION} with CMake ${CMAKE_VERSION} "
"and the `${CMAKE_GENERATOR}` Generator"
)
get_cmake_property(COR_IS_MULTI_CONFIG GENERATOR_IS_MULTI_CONFIG)
set(COR_IS_MULTI_CONFIG "${COR_IS_MULTI_CONFIG}" CACHE BOOL "Do not change this" FORCE)
mark_as_advanced(FORCE COR_IS_MULTI_CONFIG)
if (COR_IS_MULTI_CONFIG AND CMAKE_VERSION VERSION_LESS 3.20.0)
message(FATAL_ERROR "Corrosion requires at least CMake 3.20 with Multi-Config Generators such as "
"\"Ninja Multi-Config\" or Visual Studio. "
"Please use a different generator or update to cmake >= 3.20.\n"
"Note: You are using CMake ${CMAKE_VERSION} (Path: `${CMAKE_COMMAND}`) with "
" the `${CMAKE_GENERATOR}` Generator."
)
elseif(NOT COR_IS_MULTI_CONFIG AND DEFINED CMAKE_CONFIGURATION_TYPES)
message(WARNING "The Generator is ${CMAKE_GENERATOR}, which is not a multi-config "
"Generator, but CMAKE_CONFIGURATION_TYPES is set. Please don't set "
"CMAKE_CONFIGURATION_TYPES unless you are using a multi-config Generator."
)
endif()
option(CORROSION_VERBOSE_OUTPUT "Enables verbose output from Corrosion and Cargo" OFF)
set(CORROSION_NATIVE_TOOLING_DESCRIPTION
"Use native tooling - Required on CMake < 3.19 and available as a fallback option for recent versions"
)
set(CORROSION_RESPECT_OUTPUT_DIRECTORY_DESCRIPTION
"Respect the CMake target properties specifying the output directory of a target, such as
`RUNTIME_OUTPUT_DIRECTORY`. This requires CMake >= 3.19, otherwise this option is forced off."
)
option(
CORROSION_NATIVE_TOOLING
"${CORROSION_NATIVE_TOOLING_DESCRIPTION}"
OFF
)
option(CORROSION_RESPECT_OUTPUT_DIRECTORY
"${CORROSION_RESPECT_OUTPUT_DIRECTORY_DESCRIPTION}"
ON
)
option(
CORROSION_NO_WARN_PARSE_TARGET_TRIPLE_FAILED
"Surpresses a warning if the parsing the target triple failed."
OFF
)
# The native tooling is required on CMAke < 3.19 so we override whatever the user may have set.
if (CMAKE_VERSION VERSION_LESS 3.19.0)
set(CORROSION_NATIVE_TOOLING ON CACHE INTERNAL "${CORROSION_NATIVE_TOOLING_DESCRIPTION}" FORCE)
set(CORROSION_RESPECT_OUTPUT_DIRECTORY OFF CACHE INTERNAL
"${CORROSION_RESPECT_OUTPUT_DIRECTORY_DESCRIPTION}" FORCE
)
endif()
find_package(Rust REQUIRED)
if(Rust_TOOLCHAIN_IS_RUSTUP_MANAGED)
execute_process(COMMAND rustup target list --toolchain "${Rust_TOOLCHAIN}"
OUTPUT_VARIABLE AVAILABLE_TARGETS_RAW
)
string(REPLACE "\n" ";" AVAILABLE_TARGETS_RAW "${AVAILABLE_TARGETS_RAW}")
string(REPLACE " (installed)" "" "AVAILABLE_TARGETS" "${AVAILABLE_TARGETS_RAW}")
set(INSTALLED_TARGETS_RAW "${AVAILABLE_TARGETS_RAW}")
list(FILTER INSTALLED_TARGETS_RAW INCLUDE REGEX " \\(installed\\)")
string(REPLACE " (installed)" "" "INSTALLED_TARGETS" "${INSTALLED_TARGETS_RAW}")
list(TRANSFORM INSTALLED_TARGETS STRIP)
if("${Rust_CARGO_TARGET}" IN_LIST AVAILABLE_TARGETS)
message(DEBUG "Cargo target ${Rust_CARGO_TARGET} is an official target-triple")
message(DEBUG "Installed targets: ${INSTALLED_TARGETS}")
if(NOT ("${Rust_CARGO_TARGET}" IN_LIST INSTALLED_TARGETS))
message(FATAL_ERROR "Target ${Rust_CARGO_TARGET} is not installed for toolchain ${Rust_TOOLCHAIN}.\n"
"Help: Run `rustup target add --toolchain ${Rust_TOOLCHAIN} ${Rust_CARGO_TARGET}` to install "
"the missing target."
)
endif()
endif()
endif()
if(CMAKE_GENERATOR MATCHES "Visual Studio"
AND (NOT CMAKE_VS_PLATFORM_NAME STREQUAL CMAKE_VS_PLATFORM_NAME_DEFAULT)
AND Rust_VERSION VERSION_LESS "1.54")
message(FATAL_ERROR "Due to a cargo issue, cross-compiling with a Visual Studio generator and rust versions"
" before 1.54 is not supported. Rust build scripts would be linked with the cross-compiler linker, which"
" causes the build to fail. Please upgrade your Rust version to 1.54 or newer.")
endif()
if (NOT TARGET Corrosion::Generator)
message(STATUS "Using Corrosion as a subdirectory")
endif()
get_property(
RUSTC_EXECUTABLE
TARGET Rust::Rustc PROPERTY IMPORTED_LOCATION
)
get_property(
CARGO_EXECUTABLE
TARGET Rust::Cargo PROPERTY IMPORTED_LOCATION
)
# Note: Legacy function, used when respecting the `XYZ_OUTPUT_DIRECTORY` target properties is not
# possible.
function(_corrosion_set_imported_location_legacy target_name base_property filename)
foreach(config_type ${CMAKE_CONFIGURATION_TYPES})
set(binary_root "${CMAKE_CURRENT_BINARY_DIR}/${config_type}")
string(TOUPPER "${config_type}" config_type_upper)
message(DEBUG "Setting ${base_property}_${config_type_upper} for target ${target_name}"
" to `${binary_root}/${filename}`.")
# For Multiconfig we want to specify the correct location for each configuration
set_property(
TARGET ${target_name}
PROPERTY "${base_property}_${config_type_upper}"
"${binary_root}/${filename}"
)
endforeach()
if(NOT COR_IS_MULTI_CONFIG)
set(binary_root "${CMAKE_CURRENT_BINARY_DIR}")
endif()
message(DEBUG "Setting ${base_property} for target ${target_name}"
" to `${binary_root}/${filename}`.")
# IMPORTED_LOCATION must be set regardless of possible overrides. In the multiconfig case,
# the last configuration "wins".
set_property(
TARGET ${target_name}
PROPERTY "${base_property}" "${binary_root}/${filename}"
)
endfunction()
# Sets out_var to true if the byproduct copying and imported location is done in a deferred
# manner to respect target properties, etc. that may be set later.
function(_corrosion_determine_deferred_byproduct_copying_and_import_location_handling out_var)
set(${out_var} ${CORROSION_RESPECT_OUTPUT_DIRECTORY} PARENT_SCOPE)
endfunction()
function(_corrosion_bin_target_suffix target_name out_var_suffix)
get_target_property(hostbuild "${target_name}" ${_CORR_PROP_HOST_BUILD})
if((hostbuild AND CMAKE_HOST_WIN32)
OR ((NOT hostbuild) AND (Rust_CARGO_TARGET_OS STREQUAL "windows")))
set(_suffix ".exe")
elseif(Rust_CARGO_TARGET_OS STREQUAL "vxworks")
set(_suffix ".vxe")
else()
set(_suffix "")
endif()
set(${out_var_suffix} "${_suffix}" PARENT_SCOPE)
endfunction()
# Do not call this function directly!
#
# This function should be called deferred to evaluate target properties late in the configure stage.
# IMPORTED_LOCATION does not support Generator expressions, so we must evaluate the output
# directory target property value at configure time. This function must be deferred to the end of
# the configure stage, so we can be sure that the output directory is not modified afterwards.
function(_corrosion_set_imported_location_deferred target_name base_property output_directory_property filename)
# The output directory property is expected to be set on the exposed target (without postfix),
# but we need to set the imported location on the actual library target with postfix.
if("${target_name}" MATCHES "^(.+)-(static|shared)$")
set(output_dir_prop_target_name "${CMAKE_MATCH_1}")
else()
set(output_dir_prop_target_name "${target_name}")
endif()
# Append .exe suffix for executable by-products if the target is windows or if it's a host
# build and the host is Windows.
get_target_property(target_type ${target_name} TYPE)
if(${target_type} STREQUAL "EXECUTABLE" AND (NOT "${filename}" MATCHES "\.pdb$"))
_corrosion_bin_target_suffix(${target_name} "suffix")
if(suffix)
set(filename "${filename}${suffix}")
endif()
endif()
get_target_property(output_directory "${output_dir_prop_target_name}" "${output_directory_property}")
message(DEBUG "Output directory property (target ${output_dir_prop_target_name}): ${output_directory_property} dir: ${output_directory}")
foreach(config_type ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER "${config_type}" config_type_upper)
get_target_property(output_dir_curr_config ${output_dir_prop_target_name}
"${output_directory_property}_${config_type_upper}"
)
if(output_dir_curr_config)
set(curr_out_dir "${output_dir_curr_config}")
elseif(output_directory)
set(curr_out_dir "${output_directory}")
else()
set(curr_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
endif()
message(DEBUG "Setting ${base_property}_${config_type_upper} for target ${target_name}"
" to `${curr_out_dir}/${filename}`.")
# For Multiconfig we want to specify the correct location for each configuration
set_property(
TARGET ${target_name}
PROPERTY "${base_property}_${config_type_upper}"
"${curr_out_dir}/${filename}"
)
set(base_output_directory "${curr_out_dir}")
endforeach()
if(NOT COR_IS_MULTI_CONFIG)
if(output_directory)
set(base_output_directory "${output_directory}")
else()
set(base_output_directory "${CMAKE_CURRENT_BINARY_DIR}")
endif()
endif()
message(DEBUG "Setting ${base_property} for target ${target_name}"
" to `${base_output_directory}/${filename}`.")
# IMPORTED_LOCATION must be set regardless of possible overrides. In the multiconfig case,
# the last configuration "wins" (IMPORTED_LOCATION is not documented to have Genex support).
set_property(
TARGET ${target_name}
PROPERTY "${base_property}" "${base_output_directory}/${filename}"
)
endfunction()
# Helper function to call _corrosion_set_imported_location_deferred while eagerly
# evaluating arguments.
# Refer to https://cmake.org/cmake/help/latest/command/cmake_language.html#deferred-call-examples
function(_corrosion_call_set_imported_location_deferred target_name base_property output_directory_property filename)
cmake_language(EVAL CODE "
cmake_language(DEFER
CALL
_corrosion_set_imported_location_deferred
[[${target_name}]]
[[${base_property}]]
[[${output_directory_property}]]
[[${filename}]]
)
")
endfunction()
# Set the imported location of a Rust target.
#
# Rust targets are built via custom targets / custom commands. The actual artifacts are exposed
# to CMake as imported libraries / executables that depend on the cargo_build command. For CMake
# to find the built artifact we need to set the IMPORTED location to the actual location on disk.
# Corrosion tries to copy the artifacts built by cargo to standard locations. The IMPORTED_LOCATION
# is set to point to the copy, and not the original from the cargo build directory.
#
# Parameters:
# - target_name: Name of the Rust target
# - base_property: Name of the base property - i.e. `IMPORTED_LOCATION` or `IMPORTED_IMPLIB`.
# - output_directory_property: Target property name that determines the standard location for the
# artifact.
# - filename of the artifact.
function(_corrosion_set_imported_location target_name base_property output_directory_property filename)
_corrosion_determine_deferred_byproduct_copying_and_import_location_handling("defer")
if(defer)
_corrosion_call_set_imported_location_deferred("${target_name}" "${base_property}" "${output_directory_property}" "${filename}")
else()
_corrosion_set_imported_location_legacy("${target_name}" "${base_property}" "${filename}")
endif()
endfunction()
function(_corrosion_copy_byproduct_legacy target_name cargo_build_dir file_names)
if(ARGN)
message(FATAL_ERROR "Unexpected additional arguments")
endif()
if(COR_IS_MULTI_CONFIG)
set(output_dir "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>")
else()
set(output_dir "${CMAKE_CURRENT_BINARY_DIR}")
endif()
list(TRANSFORM file_names PREPEND "${cargo_build_dir}/" OUTPUT_VARIABLE src_file_names)
list(TRANSFORM file_names PREPEND "${output_dir}/" OUTPUT_VARIABLE dst_file_names)
message(DEBUG "Adding command to copy byproducts `${file_names}` to ${dst_file_names}")
add_custom_command(TARGET _cargo-build_${target_name}
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E make_directory "${output_dir}"
COMMAND
${CMAKE_COMMAND} -E copy_if_different
# tested to work with both multiple files and paths with spaces
${src_file_names}
"${output_dir}"
BYPRODUCTS ${dst_file_names}
COMMENT "Copying byproducts `${file_names}` to ${output_dir}"
VERBATIM
COMMAND_EXPAND_LISTS
)
endfunction()
function(_corrosion_copy_byproduct_deferred target_name output_dir_prop_name cargo_build_dir file_names)
if(ARGN)
message(FATAL_ERROR "Unexpected additional arguments")
endif()
get_target_property(output_dir ${target_name} "${output_dir_prop_name}")
# A Genex expanding to the output directory depending on the configuration.
set(multiconfig_out_dir_genex "")
foreach(config_type ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER "${config_type}" config_type_upper)
get_target_property(output_dir_curr_config ${target_name} "${output_dir_prop_name}_${config_type_upper}")
if(output_dir_curr_config)
set(curr_out_dir "${output_dir_curr_config}")
elseif(output_dir)
# Fallback to `output_dir` if specified
# Note: Multi-configuration generators append a per-configuration subdirectory to the
# specified directory unless a generator expression is used (from CMake documentation).
set(curr_out_dir "${output_dir}")
else()
# Fallback to the default directory. We do not append the configuration directory here
# and instead let CMake do this, since otherwise the resolving of dynamic library
# imported paths may fail.
set(curr_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
endif()
set(multiconfig_out_dir_genex "${multiconfig_out_dir_genex}$<$<CONFIG:${config_type}>:${curr_out_dir}>")
endforeach()
if(COR_IS_MULTI_CONFIG)
set(output_dir "${multiconfig_out_dir_genex}")
else()
if(NOT output_dir)
# Fallback to default directory.
set(output_dir "${CMAKE_CURRENT_BINARY_DIR}")
endif()
endif()
# Append .exe suffix for executable by-products if the target is windows or if it's a host
# build and the host is Windows.
get_target_property(target_type "${target_name}" TYPE)
if (target_type STREQUAL "EXECUTABLE")
list(LENGTH file_names list_len)
if(NOT list_len EQUAL "1")
message(FATAL_ERROR
"Internal error: Exactly one filename should be passed for executable types.")
endif()
_corrosion_bin_target_suffix(${target_name} "suffix")
if(suffix AND (NOT "${file_names}" MATCHES "\.pdb$"))
# For executable targets we know / checked that only one file will be passed.
string(APPEND file_names "${suffix}")
endif()
endif()
list(TRANSFORM file_names PREPEND "${cargo_build_dir}/" OUTPUT_VARIABLE src_file_names)
list(TRANSFORM file_names PREPEND "${output_dir}/" OUTPUT_VARIABLE dst_file_names)
message(DEBUG "Adding command to copy byproducts `${file_names}` to ${dst_file_names}")
add_custom_command(TARGET _cargo-build_${target_name}
POST_BUILD
# output_dir may contain a Generator expression.
COMMAND ${CMAKE_COMMAND} -E make_directory "${output_dir}"
COMMAND
${CMAKE_COMMAND} -E copy_if_different
# tested to work with both multiple files and paths with spaces
${src_file_names}
"${output_dir}"
BYPRODUCTS ${dst_file_names}
COMMENT "Copying byproducts `${file_names}` to ${output_dir}"
VERBATIM
COMMAND_EXPAND_LISTS
)
endfunction()
function(_corrosion_call_copy_byproduct_deferred target_name output_dir_prop_name cargo_build_dir file_names)
cmake_language(EVAL CODE "
cmake_language(DEFER
CALL
_corrosion_copy_byproduct_deferred
[[${target_name}]]
[[${output_dir_prop_name}]]
[[${cargo_build_dir}]]
[[${file_names}]]
)
")
endfunction()
# Copy the artifacts generated by cargo to the appropriate destination.
#
# Parameters:
# - target_name: The name of the Rust target
# - output_dir_prop_name: The property name controlling the destination (e.g.
# `RUNTIME_OUTPUT_DIRECTORY`)
# - cargo_build_dir: the directory cargo build places it's output artifacts in.
# - filenames: the file names of any output artifacts as a list.
# - is_binary: TRUE if the byproducts are program executables.
function(_corrosion_copy_byproducts target_name output_dir_prop_name cargo_build_dir filenames)
_corrosion_determine_deferred_byproduct_copying_and_import_location_handling("defer")
if(defer)
_corrosion_call_copy_byproduct_deferred("${target_name}" "${output_dir_prop_name}" "${cargo_build_dir}" "${filenames}")
else()
_corrosion_copy_byproduct_legacy("${target_name}" "${cargo_build_dir}" "${filenames}")
endif()
endfunction()
# Add targets for the static and/or shared libraries of the rust target.
# The generated byproduct names are returned via the `OUT_<type>_BYPRODUCTS` arguments.
function(_corrosion_add_library_target)
set(OPTIONS "")
set(ONE_VALUE_KEYWORDS
WORKSPACE_MANIFEST_PATH
TARGET_NAME
OUT_ARCHIVE_OUTPUT_BYPRODUCTS
OUT_SHARED_LIB_BYPRODUCTS
OUT_PDB_BYPRODUCT
)
set(MULTI_VALUE_KEYWORDS LIB_KINDS)
cmake_parse_arguments(PARSE_ARGV 0 CALT "${OPTIONS}" "${ONE_VALUE_KEYWORDS}" "${MULTI_VALUE_KEYWORDS}")
if(DEFINED CALT_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Internal error - unexpected arguments: ${CALT_UNPARSED_ARGUMENTS}")
elseif(DEFINED CALT_KEYWORDS_MISSING_VALUES)
message(FATAL_ERROR "Internal error - the following keywords had no associated value(s):"
"${CALT_KEYWORDS_MISSING_VALUES}")
endif()
list(TRANSFORM ONE_VALUE_KEYWORDS PREPEND CALT_ OUTPUT_VARIABLE required_arguments)
foreach(required_argument ${required_arguments} )
if(NOT DEFINED "${required_argument}")
message(FATAL_ERROR "Internal error: Missing required argument ${required_argument}."
"Complete argument list: ${ARGN}"
)
endif()
endforeach()
if("staticlib" IN_LIST CALT_LIB_KINDS)
set(has_staticlib TRUE)
endif()
if("cdylib" IN_LIST CALT_LIB_KINDS)
set(has_cdylib TRUE)
endif()
if(NOT (has_staticlib OR has_cdylib))
message(FATAL_ERROR "Unknown library type(s): ${CALT_LIB_KINDS}")
endif()
set(workspace_manifest_path "${CALT_WORKSPACE_MANIFEST_PATH}")
set(target_name "${CALT_TARGET_NAME}")
set(is_windows "")
set(is_windows_gnu "")
set(is_windows_msvc "")
set(is_macos "")
if(Rust_CARGO_TARGET_OS STREQUAL "windows")
set(is_windows TRUE)
if(Rust_CARGO_TARGET_ENV STREQUAL "msvc")
set(is_windows_msvc TRUE)
elseif(Rust_CARGO_TARGET_ENV STREQUAL "gnu")
set(is_windows_gnu TRUE)
endif()
elseif(Rust_CARGO_TARGET_OS STREQUAL "darwin")
set(is_macos TRUE)
endif()
# target file names
string(REPLACE "-" "_" lib_name "${target_name}")
if(is_windows_msvc)
set(static_lib_name "${lib_name}.lib")
else()
set(static_lib_name "lib${lib_name}.a")
endif()
if(is_windows)
set(dynamic_lib_name "${lib_name}.dll")
elseif(is_macos)
set(dynamic_lib_name "lib${lib_name}.dylib")
else()
set(dynamic_lib_name "lib${lib_name}.so")
endif()
if(is_windows_msvc)
set(implib_name "${lib_name}.dll.lib")
elseif(is_windows_gnu)
set(implib_name "lib${lib_name}.dll.a")
elseif(is_windows)
message(FATAL_ERROR "Unknown windows environment - Can't determine implib name")
endif()
set(pdb_name "${lib_name}.pdb")
set(archive_output_byproducts "")
if(has_staticlib)
list(APPEND archive_output_byproducts ${static_lib_name})
endif()
if(has_cdylib)
set("${CALT_OUT_SHARED_LIB_BYPRODUCTS}" "${dynamic_lib_name}" PARENT_SCOPE)
if(is_windows)
list(APPEND archive_output_byproducts ${implib_name})
endif()
if(is_windows_msvc)
set("${CALT_OUT_PDB_BYPRODUCT}" "${pdb_name}" PARENT_SCOPE)
endif()
endif()
set("${CALT_OUT_ARCHIVE_OUTPUT_BYPRODUCTS}" "${archive_output_byproducts}" PARENT_SCOPE)
add_library(${target_name} INTERFACE)
if(has_staticlib)
add_library(${target_name}-static STATIC IMPORTED GLOBAL)
add_dependencies(${target_name}-static cargo-build_${target_name})
_corrosion_set_imported_location("${target_name}-static" "IMPORTED_LOCATION"
"ARCHIVE_OUTPUT_DIRECTORY"
"${static_lib_name}")
# Todo: NO_STD target property?
if(NOT COR_NO_STD)
set_property(
TARGET ${target_name}-static
PROPERTY INTERFACE_LINK_LIBRARIES ${Rust_CARGO_TARGET_LINK_NATIVE_LIBS}
)
set_property(
TARGET ${target_name}-static
PROPERTY INTERFACE_LINK_OPTIONS ${Rust_CARGO_TARGET_LINK_OPTIONS}
)
if(is_macos)
set_property(TARGET ${target_name}-static
PROPERTY INTERFACE_LINK_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib"
)
endif()
endif()
endif()
if(has_cdylib)
add_library(${target_name}-shared SHARED IMPORTED GLOBAL)
add_dependencies(${target_name}-shared cargo-build_${target_name})
# Todo: (Not new issue): What about IMPORTED_SONAME and IMPORTED_NO_SYSTEM?
_corrosion_set_imported_location("${target_name}-shared" "IMPORTED_LOCATION"
"LIBRARY_OUTPUT_DIRECTORY"
"${dynamic_lib_name}"
)
# In the future we would probably prefer to let Rust set the soname for packages >= 1.0.
# This is tracked in issue #333.
set_target_properties(${target_name}-shared PROPERTIES IMPORTED_NO_SONAME TRUE)
if(is_windows)
_corrosion_set_imported_location("${target_name}-shared" "IMPORTED_IMPLIB"
"ARCHIVE_OUTPUT_DIRECTORY"
"${implib_name}"
)
endif()
if(is_macos)
set_property(TARGET ${target_name}-shared
PROPERTY INTERFACE_LINK_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib"
)
endif()
endif()
if(has_cdylib AND has_staticlib)
if(BUILD_SHARED_LIBS)
target_link_libraries(${target_name} INTERFACE ${target_name}-shared)
else()
target_link_libraries(${target_name} INTERFACE ${target_name}-static)
endif()
elseif(has_cdylib)
target_link_libraries(${target_name} INTERFACE ${target_name}-shared)
else()
target_link_libraries(${target_name} INTERFACE ${target_name}-static)
endif()
endfunction()
function(_corrosion_add_bin_target workspace_manifest_path bin_name out_bin_byproduct out_pdb_byproduct)
if(NOT bin_name)
message(FATAL_ERROR "No bin_name in _corrosion_add_bin_target for target ${target_name}")
endif()
string(REPLACE "-" "_" bin_name_underscore "${bin_name}")
set(pdb_name "${bin_name_underscore}.pdb")
if(Rust_CARGO_TARGET_ENV STREQUAL "msvc")
set(${out_pdb_byproduct} "${pdb_name}" PARENT_SCOPE)
endif()
set(bin_filename "${bin_name}")
_corrosion_determine_deferred_byproduct_copying_and_import_location_handling("defer")
if(defer)
# .exe suffix will be added later, also depending on possible hostbuild
# target property
else()
if(Rust_CARGO_TARGET_OS STREQUAL "windows")
set(bin_filename "${bin_name}.exe")
endif()
endif()
set(${out_bin_byproduct} "${bin_filename}" PARENT_SCOPE)
# Todo: This is compatible with the way corrosion previously exposed the bin name,
# but maybe we want to prefix the exposed name with the package name?
add_executable(${bin_name} IMPORTED GLOBAL)
add_dependencies(${bin_name} cargo-build_${bin_name})
if(Rust_CARGO_TARGET_OS STREQUAL "darwin")
set_property(TARGET ${bin_name}
PROPERTY INTERFACE_LINK_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib"
)
endif()
_corrosion_set_imported_location("${bin_name}" "IMPORTED_LOCATION"
"RUNTIME_OUTPUT_DIRECTORY"
"${bin_filename}"
)
endfunction()
if (NOT CORROSION_NATIVE_TOOLING)
include(CorrosionGenerator)
endif()
# Note: `cmake_language(GET_MESSAGE_LOG_LEVEL <output_variable>)` requires CMake 3.25,
# so we offer our own option to control verbosity of downstream commands (e.g. cargo build)
if (CORROSION_VERBOSE_OUTPUT)
set(_CORROSION_VERBOSE_OUTPUT_FLAG --verbose CACHE INTERNAL "")
else()
# We want to silence some less important commands by default.
set(_CORROSION_QUIET_OUTPUT_FLAG --quiet CACHE INTERNAL "")
endif()
if(CORROSION_NATIVE_TOOLING)
if (NOT TARGET Corrosion::Generator )
add_subdirectory(generator)
endif()
get_property(
_CORROSION_GENERATOR_EXE
TARGET Corrosion::Generator PROPERTY IMPORTED_LOCATION
)
set(
_CORROSION_GENERATOR
${CMAKE_COMMAND} -E env
CARGO_BUILD_RUSTC=${RUSTC_EXECUTABLE}
${_CORROSION_GENERATOR_EXE}
--cargo ${CARGO_EXECUTABLE}
${_CORROSION_VERBOSE_OUTPUT_FLAG}
CACHE INTERNAL "corrosion-generator runner"
)
endif()
set(_CORROSION_CARGO_VERSION ${Rust_CARGO_VERSION} CACHE INTERNAL "cargo version used by corrosion")
set(_CORROSION_RUST_CARGO_TARGET ${Rust_CARGO_TARGET} CACHE INTERNAL "target triple used by corrosion")
set(_CORROSION_RUST_CARGO_HOST_TARGET ${Rust_CARGO_HOST_TARGET} CACHE INTERNAL "host triple used by corrosion")
set(_CORROSION_RUSTC "${RUSTC_EXECUTABLE}" CACHE INTERNAL "Path to rustc used by corrosion")
set(_CORROSION_CARGO "${CARGO_EXECUTABLE}" CACHE INTERNAL "Path to cargo used by corrosion")
string(REPLACE "-" "_" _CORROSION_RUST_CARGO_TARGET_UNDERSCORE "${Rust_CARGO_TARGET}")
set(_CORROSION_RUST_CARGO_TARGET_UNDERSCORE "${_CORROSION_RUST_CARGO_TARGET_UNDERSCORE}" CACHE INTERNAL "lowercase target triple with underscores")
string(TOUPPER "${_CORROSION_RUST_CARGO_TARGET_UNDERSCORE}" _CORROSION_TARGET_TRIPLE_UPPER)
set(_CORROSION_RUST_CARGO_TARGET_UPPER
"${_CORROSION_TARGET_TRIPLE_UPPER}"
CACHE INTERNAL
"target triple in uppercase with underscore"
)
# We previously specified some Custom properties as part of our public API, however the chosen names prevented us from
# supporting CMake versions before 3.19. In order to both support older CMake versions and not break existing code
# immediately, we are using a different property name depending on the CMake version. However users avoid using
# any of the properties directly, as they are no longer part of the public API and are to be considered deprecated.
# Instead use the corrosion_set_... functions as documented in the Readme.
if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.19.0)
set(_CORR_PROP_FEATURES CORROSION_FEATURES CACHE INTERNAL "")
set(_CORR_PROP_ALL_FEATURES CORROSION_ALL_FEATURES CACHE INTERNAL "")
set(_CORR_PROP_NO_DEFAULT_FEATURES CORROSION_NO_DEFAULT_FEATURES CACHE INTERNAL "")
set(_CORR_PROP_ENV_VARS CORROSION_ENVIRONMENT_VARIABLES CACHE INTERNAL "")
set(_CORR_PROP_HOST_BUILD CORROSION_USE_HOST_BUILD CACHE INTERNAL "")
else()
set(_CORR_PROP_FEATURES INTERFACE_CORROSION_FEATURES CACHE INTERNAL "")
set(_CORR_PROP_ALL_FEATURES INTERFACE_CORROSION_ALL_FEATURES CACHE INTERNAL "")
set(_CORR_PROP_NO_DEFAULT_FEATURES INTERFACE_NO_DEFAULT_FEATURES CACHE INTERNAL "")
set(_CORR_PROP_ENV_VARS INTERFACE_CORROSION_ENVIRONMENT_VARIABLES CACHE INTERNAL "")
set(_CORR_PROP_HOST_BUILD INTERFACE_CORROSION_USE_HOST_BUILD CACHE INTERNAL "")
endif()
# Add custom command to build one target in a package (crate)
#
# A target may be either a specific bin
function(_add_cargo_build out_cargo_build_out_dir)
set(options NO_LINKER_OVERRIDE)
set(one_value_args PACKAGE TARGET MANIFEST_PATH WORKSPACE_MANIFEST_PATH)
set(multi_value_args BYPRODUCTS TARGET_KINDS)
cmake_parse_arguments(
ACB
"${options}"
"${one_value_args}"
"${multi_value_args}"
${ARGN}
)
if(DEFINED ACB_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Internal error - unexpected arguments: "
${ACB_UNPARSED_ARGUMENTS})
elseif(DEFINED ACB_KEYWORDS_MISSING_VALUES)
message(FATAL_ERROR "Internal error - missing values for the following arguments: "
${ACB_KEYWORDS_MISSING_VALUES})
endif()
set(package_name "${ACB_PACKAGE}")
set(target_name "${ACB_TARGET}")
set(path_to_toml "${ACB_MANIFEST_PATH}")
set(target_kinds "${ACB_TARGET_KINDS}")
set(workspace_manifest_path "${ACB_WORKSPACE_MANIFEST_PATH}")
if(NOT target_kinds)
message(FATAL_ERROR "TARGET_KINDS not specified")
elseif("staticlib" IN_LIST target_kinds OR "cdylib" IN_LIST target_kinds)
set(cargo_rustc_filter "--lib")
elseif("bin" IN_LIST target_kinds)
set(cargo_rustc_filter "--bin=${target_name}")
else()
message(FATAL_ERROR "TARGET_KINDS contained unknown kind `${target_kind}`")
endif()
if (NOT IS_ABSOLUTE "${path_to_toml}")
set(path_to_toml "${CMAKE_SOURCE_DIR}/${path_to_toml}")
endif()
get_filename_component(workspace_toml_dir ${path_to_toml} DIRECTORY )
if (CMAKE_VS_PLATFORM_NAME)
set (build_dir "${CMAKE_VS_PLATFORM_NAME}/$<CONFIG>")
elseif(COR_IS_MULTI_CONFIG)
set (build_dir "$<CONFIG>")
else()
set (build_dir .)
endif()
# If a CMake sysroot is specified, forward it to the linker rustc invokes, too. CMAKE_SYSROOT is documented
# to be passed via --sysroot, so we assume that when it's set, the linker supports this option in that style.
if(CMAKE_CROSSCOMPILING AND CMAKE_SYSROOT)
set(corrosion_link_args "--sysroot=${CMAKE_SYSROOT}")
endif()
if(COR_ALL_FEATURES)
set(all_features_arg --all-features)
endif()
if(COR_NO_DEFAULT_FEATURES)
set(no_default_features_arg --no-default-features)
endif()
set(global_rustflags_target_property "$<TARGET_GENEX_EVAL:${target_name},$<TARGET_PROPERTY:${target_name},INTERFACE_CORROSION_RUSTFLAGS>>")
set(local_rustflags_target_property "$<TARGET_GENEX_EVAL:${target_name},$<TARGET_PROPERTY:${target_name},INTERFACE_CORROSION_LOCAL_RUSTFLAGS>>")
# todo: this probably should be TARGET_GENEX_EVAL
set(features_target_property "$<GENEX_EVAL:$<TARGET_PROPERTY:${target_name},${_CORR_PROP_FEATURES}>>")
set(features_genex "$<$<BOOL:${features_target_property}>:--features=$<JOIN:${features_target_property},$<COMMA>>>")
# target property overrides corrosion_import_crate argument
set(all_features_target_property "$<GENEX_EVAL:$<TARGET_PROPERTY:${target_name},${_CORR_PROP_ALL_FEATURES}>>")
set(all_features_arg "$<$<BOOL:${all_features_target_property}>:--all-features>")
set(no_default_features_target_property "$<GENEX_EVAL:$<TARGET_PROPERTY:${target_name},${_CORR_PROP_NO_DEFAULT_FEATURES}>>")
set(no_default_features_arg "$<$<BOOL:${no_default_features_target_property}>:--no-default-features>")
set(build_env_variable_genex "$<GENEX_EVAL:$<TARGET_PROPERTY:${target_name},${_CORR_PROP_ENV_VARS}>>")
set(hostbuild_override "$<BOOL:$<TARGET_PROPERTY:${target_name},${_CORR_PROP_HOST_BUILD}>>")
set(if_not_host_build_condition "$<NOT:${hostbuild_override}>")
set(corrosion_link_args "$<${if_not_host_build_condition}:${corrosion_link_args}>")
# We always set `--target`, so that cargo always places artifacts into a directory with the
# target triple.
set(cargo_target_option "--target=$<IF:${hostbuild_override},${_CORROSION_RUST_CARGO_HOST_TARGET},${_CORROSION_RUST_CARGO_TARGET}>")
# The target may be a filepath to custom target json file. For host targets we assume that they are built-in targets.
_corrosion_strip_target_triple(${_CORROSION_RUST_CARGO_TARGET} stripped_target_triple)
set(target_artifact_dir "$<IF:${hostbuild_override},${_CORROSION_RUST_CARGO_HOST_TARGET},${stripped_target_triple}>")
set(flags_genex "$<GENEX_EVAL:$<TARGET_PROPERTY:${target_name},INTERFACE_CORROSION_CARGO_FLAGS>>")
set(explicit_linker_property "$<TARGET_PROPERTY:${target_name},INTERFACE_CORROSION_LINKER>")
set(explicit_linker_defined "$<BOOL:${explicit_linker_property}>")
set(cargo_profile_target_property "$<TARGET_GENEX_EVAL:${target_name},$<TARGET_PROPERTY:${target_name},INTERFACE_CORROSION_CARGO_PROFILE>>")
# Option to override the rustc/cargo binary to something other than the global default
set(rustc_override "$<TARGET_PROPERTY:${target_name},INTERFACE_CORROSION_RUSTC>")
set(cargo_override "$<TARGET_PROPERTY:${target_name},INTERFACE_CORROSION_CARGO>")
set(rustc_bin "$<IF:$<BOOL:${rustc_override}>,${rustc_override},${_CORROSION_RUSTC}>")
set(cargo_bin "$<IF:$<BOOL:${cargo_override}>,${cargo_override},${_CORROSION_CARGO}>")
# Rust will add `-lSystem` as a flag for the linker on macOS. Adding the -L flag via RUSTFLAGS only fixes the
# problem partially - buildscripts still break, since they won't receive the RUSTFLAGS. This seems to only be a
# problem if we specify the linker ourselves (which we do, since this is necessary for e.g. linking C++ code).
# We can however set `LIBRARY_PATH`, which is propagated to the build-script-build properly.
if(NOT CMAKE_CROSSCOMPILING AND CMAKE_SYSTEM_NAME STREQUAL "Darwin")
# not needed anymore on macos 13 (and causes issues)
if(${CMAKE_SYSTEM_VERSION} VERSION_LESS 22)
set(cargo_library_path "LIBRARY_PATH=/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib")
endif()
elseif(CMAKE_CROSSCOMPILING AND CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
if(${CMAKE_HOST_SYSTEM_VERSION} VERSION_LESS 22)
set(cargo_library_path "$<${hostbuild_override}:LIBRARY_PATH=/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib>")
endif()
endif()
set(cargo_profile_set "$<BOOL:${cargo_profile_target_property}>")
# In the default case just specify --release or nothing to stay compatible with
# older rust versions.
set(default_profile_option "$<$<NOT:$<OR:$<CONFIG:Debug>,$<CONFIG:>>>:--release>")
# evaluates to either `--profile=<custom_profile>`, `--release` or nothing (for debug).
set(cargo_profile "$<IF:${cargo_profile_set},--profile=${cargo_profile_target_property},${default_profile_option}>")
# If the profile name is `dev` change the dir name to `debug`.
set(is_dev_profile "$<STREQUAL:${cargo_profile_target_property},dev>")
set(profile_dir_override "$<${is_dev_profile}:debug>")
set(profile_dir_is_overridden "$<BOOL:${profile_dir_override}>")
set(custom_profile_build_type_dir "$<IF:${profile_dir_is_overridden},${profile_dir_override},${cargo_profile_target_property}>")
set(default_build_type_dir "$<IF:$<OR:$<CONFIG:Debug>,$<CONFIG:>>,debug,release>")
set(build_type_dir "$<IF:${cargo_profile_set},${custom_profile_build_type_dir},${default_build_type_dir}>")
set(cargo_target_dir "${CMAKE_BINARY_DIR}/${build_dir}/cargo/build")
set(cargo_build_dir "${cargo_target_dir}/${target_artifact_dir}/${build_type_dir}")
set("${out_cargo_build_out_dir}" "${cargo_build_dir}" PARENT_SCOPE)
set(corrosion_cc_rs_flags)
if(CMAKE_C_COMPILER)
# This variable is read by cc-rs (often used in build scripts) to determine the c-compiler.
# It can still be overridden if the user sets the non underscore variant via the environment variables
# on the target.
list(APPEND corrosion_cc_rs_flags "CC_${_CORROSION_RUST_CARGO_TARGET_UNDERSCORE}=${CMAKE_C_COMPILER}")
endif()
if(CMAKE_CXX_COMPILER)
list(APPEND corrosion_cc_rs_flags "CXX_${_CORROSION_RUST_CARGO_TARGET_UNDERSCORE}=${CMAKE_CXX_COMPILER}")
endif()
# cc-rs doesn't seem to support `llvm-ar` (commandline syntax), wo we might as well just use
# the default AR.
if(CMAKE_AR AND NOT (Rust_CARGO_TARGET_ENV STREQUAL "msvc"))
list(APPEND corrosion_cc_rs_flags "AR_${_CORROSION_RUST_CARGO_TARGET_UNDERSCORE}=${CMAKE_AR}")
endif()
# Since we instruct cc-rs to use the compiler found by CMake, it is likely one that requires also
# specifying the target sysroot to use. CMake's generator makes sure to pass --sysroot with
# CMAKE_OSX_SYSROOT. Fortunately the compilers Apple ships also respect the SDKROOT environment
# variable, which we can set for use when cc-rs invokes the compiler.
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin" AND CMAKE_OSX_SYSROOT)
list(APPEND corrosion_cc_rs_flags "SDKROOT=${CMAKE_OSX_SYSROOT}")
endif()
corrosion_add_target_local_rustflags("${target_name}" "$<$<BOOL:${corrosion_link_args}>:-Clink-args=${corrosion_link_args}>")
# todo: this should probably also be guarded by if_not_host_build_condition.
if(COR_NO_STD)
corrosion_add_target_local_rustflags("${target_name}" "-Cdefault-linker-libraries=no")
else()
corrosion_add_target_local_rustflags("${target_name}" "-Cdefault-linker-libraries=yes")
endif()
set(global_joined_rustflags "$<JOIN:${global_rustflags_target_property}, >")
set(global_rustflags_genex "$<$<BOOL:${global_rustflags_target_property}>:RUSTFLAGS=${global_joined_rustflags}>")
set(local_rustflags_delimiter "$<$<BOOL:${local_rustflags_target_property}>:-->")
set(local_rustflags_genex "$<$<BOOL:${local_rustflags_target_property}>:${local_rustflags_target_property}>")
set(deps_link_languages_prop "$<TARGET_PROPERTY:_cargo-build_${target_name},CARGO_DEPS_LINKER_LANGUAGES>")
set(deps_link_languages "$<TARGET_GENEX_EVAL:_cargo-build_${target_name},${deps_link_languages_prop}>")
set(target_uses_cxx "$<IN_LIST:CXX,${deps_link_languages}>")
unset(default_linker)
# With the MSVC ABI rustc only supports directly invoking the linker - Invoking cl as the linker driver is not supported.
if(NOT (Rust_CARGO_TARGET_ENV STREQUAL "msvc" OR COR_NO_LINKER_OVERRIDE))
set(default_linker "$<IF:$<BOOL:${target_uses_cxx}>,${CMAKE_CXX_COMPILER},${CMAKE_C_COMPILER}>")
endif()
# Used to set a linker for a specific target-triple.
set(cargo_target_linker_var "CARGO_TARGET_${_CORROSION_RUST_CARGO_TARGET_UPPER}_LINKER")
set(linker "$<IF:${explicit_linker_defined},${explicit_linker_property},${default_linker}>")
set(cargo_target_linker $<$<BOOL:${linker}>:${cargo_target_linker_var}=${linker}>)
if(Rust_CROSSCOMPILING AND (CMAKE_C_COMPILER_TARGET OR CMAKE_CXX_COMPILER_TARGET))
set(linker_target_triple "$<IF:$<BOOL:${target_uses_cxx}>,${CMAKE_CXX_COMPILER_TARGET},${CMAKE_C_COMPILER_TARGET}>")
set(rustflag_linker_arg "-Clink-args=--target=${linker_target_triple}")
set(rustflag_linker_arg "$<${if_not_host_build_condition}:${rustflag_linker_arg}>")
# Skip adding the linker argument, if the linker is explicitly set, since the
# explicit_linker_property will not be set when this function runs.
# Passing this rustflag is necessary for clang.
corrosion_add_target_local_rustflags("${target_name}" "$<$<NOT:${explicit_linker_defined}>:${rustflag_linker_arg}>")
endif()
message(DEBUG "TARGET ${target_name} produces byproducts ${byproducts}")
add_custom_target(
_cargo-build_${target_name}
# Build crate
COMMAND
${CMAKE_COMMAND} -E env
"${build_env_variable_genex}"
"${global_rustflags_genex}"
"${cargo_target_linker}"
"${corrosion_cc_rs_flags}"
"${cargo_library_path}"
"CORROSION_BUILD_DIR=${CMAKE_CURRENT_BINARY_DIR}"
"CARGO_BUILD_RUSTC=${rustc_bin}"
"${cargo_bin}"
rustc
${cargo_rustc_filter}
${cargo_target_option}
${_CORROSION_VERBOSE_OUTPUT_FLAG}
${all_features_arg}
${no_default_features_arg}
${features_genex}
--package ${package_name}
--manifest-path "${path_to_toml}"
--target-dir "${cargo_target_dir}"
${cargo_profile}
${flags_genex}
# Any arguments to cargo must be placed before this line
${local_rustflags_delimiter}
${local_rustflags_genex}
# Note: Adding `build_byproducts` (the byproducts in the cargo target directory) here
# causes CMake to fail during the Generate stage, because the target `target_name` was not
# found. I don't know why this happens, so we just don't specify byproducts here and
# only specify the actual byproducts in the `POST_BUILD` custom command that copies the
# byproducts to the final destination.
# BYPRODUCTS ${build_byproducts}
# The build is conducted in the directory of the Manifest, so that configuration files such as
# `.cargo/config.toml` or `toolchain.toml` are applied as expected.
WORKING_DIRECTORY "${workspace_toml_dir}"
USES_TERMINAL
COMMAND_EXPAND_LISTS
VERBATIM
)
# User exposed custom target, that depends on the internal target.
# Corrosion post build steps are added on the internal target, which
# ensures that they run before any user defined post build steps on this
# target.
add_custom_target(
cargo-build_${target_name}
ALL
)
add_dependencies(cargo-build_${target_name} _cargo-build_${target_name})
# Add custom target before actual build that user defined custom commands (e.g. code generators) can
# use as a hook to do something before the build. This mainly exists to not expose the `_cargo-build` targets.
add_custom_target(cargo-prebuild_${target_name})
add_dependencies(_cargo-build_${target_name} cargo-prebuild_${target_name})
if(NOT TARGET cargo-prebuild)
add_custom_target(cargo-prebuild)
endif()
add_dependencies(cargo-prebuild cargo-prebuild_${target_name})
add_custom_target(
cargo-clean_${target_name}
COMMAND
"${cargo_bin}" clean ${cargo_target_option}
-p ${package_name} --manifest-path ${path_to_toml}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/${build_dir}
USES_TERMINAL
)
if (NOT TARGET cargo-clean)
add_custom_target(cargo-clean)
endif()
add_dependencies(cargo-clean cargo-clean_${target_name})
endfunction()
#[=======================================================================[.md:
ANCHOR: corrosion-import-crate
```cmake
corrosion_import_crate(
MANIFEST_PATH <path/to/cargo.toml>
[ALL_FEATURES]
[NO_DEFAULT_FEATURES]
[NO_STD]
[NO_LINKER_OVERRIDE]
[LOCKED]
[FROZEN]
[PROFILE <cargo-profile>]
[IMPORTED_CRATES <variable-name>]
[CRATE_TYPES <crate_type1> ... <crate_typeN>]
[CRATES <crate1> ... <crateN>]
[FEATURES <feature1> ... <featureN>]
[FLAGS <flag1> ... <flagN>]
)
```
* **MANIFEST_PATH**: Path to a [Cargo.toml Manifest] file.
* **ALL_FEATURES**: Equivalent to [--all-features] passed to cargo build
* **NO_DEFAULT_FEATURES**: Equivalent to [--no-default-features] passed to cargo build
* **NO_STD**: Disable linking of standard libraries (required for no_std crates).
* **NO_LINKER_OVERRIDE**: Will let Rust/Cargo determine which linker to use instead of corrosion (when linking is invoked by Rust)
* **LOCKED**: Pass [`--locked`] to cargo build and cargo metadata.
* **FROZEN**: Pass [`--frozen`] to cargo build and cargo metadata.
* **PROFILE**: Specify cargo build profile (`dev`/`release` or a [custom profile]; `bench` and `test` are not supported)
* **IMPORTED_CRATES**: Save the list of imported crates into the variable with the provided name in the current scope.
* **CRATE_TYPES**: Only import the specified crate types. Valid values: `staticlib`, `cdylib`, `bin`.
* **CRATES**: Only import the specified crates from a workspace. Values: Crate names.
* **FEATURES**: Enable the specified features. Equivalent to [--features] passed to `cargo build`.
* **FLAGS**: Arbitrary flags to `cargo build`.
[custom profile]: https://doc.rust-lang.org/cargo/reference/profiles.html#custom-profiles
[--all-features]: https://doc.rust-lang.org/cargo/reference/features.html#command-line-feature-options
[--no-default-features]: https://doc.rust-lang.org/cargo/reference/features.html#command-line-feature-options
[--features]: https://doc.rust-lang.org/cargo/reference/features.html#command-line-feature-options
[`--locked`]: https://doc.rust-lang.org/cargo/commands/cargo.html#manifest-options
[`--frozen`]: https://doc.rust-lang.org/cargo/commands/cargo.html#manifest-options
[Cargo.toml Manifest]: https://doc.rust-lang.org/cargo/appendix/glossary.html#manifest
ANCHOR_END: corrosion-import-crate
#]=======================================================================]
function(corrosion_import_crate)
set(OPTIONS ALL_FEATURES NO_DEFAULT_FEATURES NO_STD NO_LINKER_OVERRIDE LOCKED FROZEN)
set(ONE_VALUE_KEYWORDS MANIFEST_PATH PROFILE IMPORTED_CRATES)
set(MULTI_VALUE_KEYWORDS CRATE_TYPES CRATES FEATURES FLAGS)
cmake_parse_arguments(COR "${OPTIONS}" "${ONE_VALUE_KEYWORDS}" "${MULTI_VALUE_KEYWORDS}" ${ARGN})
list(APPEND CMAKE_MESSAGE_CONTEXT "corrosion_import_crate")
if(DEFINED COR_UNPARSED_ARGUMENTS)
message(AUTHOR_WARNING "Unexpected arguments: " ${COR_UNPARSED_ARGUMENTS}
"\nCorrosion will ignore these unexpected arguments."
)
endif()
if(DEFINED COR_KEYWORDS_MISSING_VALUES)
message(DEBUG "Note: the following keywords passed to corrosion_import_crate had no associated value(s): "
${COR_KEYWORDS_MISSING_VALUES}
)
endif()
if (NOT DEFINED COR_MANIFEST_PATH)
message(FATAL_ERROR "MANIFEST_PATH is a required keyword to corrosion_add_crate")
endif()
_corrosion_option_passthrough_helper(NO_LINKER_OVERRIDE COR no_linker_override)
_corrosion_option_passthrough_helper(LOCKED COR locked)
_corrosion_option_passthrough_helper(FROZEN COR frozen)
_corrosion_arg_passthrough_helper(CRATES COR crate_allowlist)
_corrosion_arg_passthrough_helper(CRATE_TYPES COR crate_types)
if(COR_PROFILE)
if(Rust_VERSION VERSION_LESS 1.57.0)
message(FATAL_ERROR "Selecting custom profiles via `PROFILE` requires at least rust 1.57.0, but you "
"have ${Rust_VERSION}."
)
# The profile name could be part of a Generator expression, so this won't catch all occurences.
# Since it is hard to add an error message for genex, we don't do that here.
elseif("${COR_PROFILE}" STREQUAL "test" OR "${COR_PROFILE}" STREQUAL "bench")
message(FATAL_ERROR "Corrosion does not support building Rust crates with the cargo profiles"
" `test` or `bench`. These profiles add a hash to the output artifact name that we"
" cannot predict. Please consider using a custom cargo profile which inherits from the"
" built-in profile instead."
)
endif()
endif()
if (NOT IS_ABSOLUTE "${COR_MANIFEST_PATH}")
set(COR_MANIFEST_PATH ${CMAKE_CURRENT_SOURCE_DIR}/${COR_MANIFEST_PATH})
endif()
set(additional_cargo_flags ${COR_FLAGS})
if(COR_LOCKED AND NOT "--locked" IN_LIST additional_cargo_flags)
list(APPEND additional_cargo_flags "--locked")
endif()
if(COR_FROZEN AND NOT "--frozen" IN_LIST additional_cargo_flags)
list(APPEND additional_cargo_flags "--frozen")
endif()
set(imported_crates "")
if (CORROSION_NATIVE_TOOLING)
get_filename_component(manifest_directory "${COR_MANIFEST_PATH}" DIRECTORY)
get_filename_component(toml_dir_name ${manifest_directory} NAME)
set(
generated_cmake
"${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/corrosion/${toml_dir_name}.dir/cargo-build.cmake"
)
if (CMAKE_VS_PLATFORM_NAME)
set (_CORROSION_CONFIGURATION_ROOT --configuration-root ${CMAKE_VS_PLATFORM_NAME})
endif()
set(crates_args)
foreach(crate ${COR_CRATES})
list(APPEND crates_args --crates ${crate})
endforeach()
if(DEFINED COR_CRATE_TYPES)
set(crate_types "--crate-type=${COR_CRATE_TYPES}")
endif()
list(APPEND passthrough_to_acb_args ${no_linker_override})
if(passthrough_to_acb_args)
# 31 == 0x1f
string(ASCII 31 unit_seperator)
list(JOIN passthrough_to_acb_args "${unit_seperator}" joined_args)
set(passthrough_to_acb "--passthrough-acb=${joined_args}")
endif()
execute_process(
COMMAND
${_CORROSION_GENERATOR}
--manifest-path ${COR_MANIFEST_PATH}
gen-cmake
${_CORROSION_CONFIGURATION_ROOT}
${crates_args}
${crate_types}
--imported-crates=imported_crates
${passthrough_to_acb}
-o ${generated_cmake}
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
RESULT_VARIABLE ret)
if (NOT ret EQUAL "0")
message(FATAL_ERROR "corrosion-generator failed")
endif()
include(${generated_cmake})
else()
_generator_add_cargo_targets(
MANIFEST_PATH
"${COR_MANIFEST_PATH}"
IMPORTED_CRATES
imported_crates
${crate_allowlist}
${crate_types}
${no_linker_override}
)
endif()
# Not target props yet:
# NO_STD
# NO_LINKER_OVERRIDE # We could simply zero INTERFACE_CORROSION_LINKER if this is set.
# LOCKED / FROZEN get merged into FLAGS after cargo metadata.
# Initialize the target properties with the arguments to corrosion_import_crate.
set_target_properties(
${imported_crates}
PROPERTIES
"${_CORR_PROP_ALL_FEATURES}" "${COR_ALL_FEATURES}"
"${_CORR_PROP_NO_DEFAULT_FEATURES}" "${COR_NO_DEFAULT_FEATURES}"
"${_CORR_PROP_FEATURES}" "${COR_FEATURES}"
INTERFACE_CORROSION_CARGO_PROFILE "${COR_PROFILE}"
INTERFACE_CORROSION_CARGO_FLAGS "${additional_cargo_flags}"
)
# _CORR_PROP_ENV_VARS
if(DEFINED COR_IMPORTED_CRATES)
set(${COR_IMPORTED_CRATES} ${imported_crates} PARENT_SCOPE)
endif()
endfunction()
function(corrosion_set_linker_language target_name language)
message(FATAL_ERROR "corrosion_set_linker_language was deprecated and removed."
"Please use corrosion_set_linker and set a specific linker.")
endfunction()
function(corrosion_set_linker target_name linker)
if(NOT linker)
message(FATAL_ERROR "The linker passed to `corrosion_set_linker` may not be empty")
elseif(NOT TARGET "${target_name}")
message(FATAL_ERROR "The target `${target_name}` does not exist.")
endif()
if(MSVC)
message(WARNING "Explicitly setting the linker with the MSVC toolchain is currently not supported and ignored")
endif()
if(TARGET "${target_name}-static" AND NOT TARGET "${target_name}-shared")
message(WARNING "The target ${target_name} builds a static library."
"The linker is never invoked for a static library so specifying a linker has no effect."
)
endif()
set_property(
TARGET ${target_name}
PROPERTY INTERFACE_CORROSION_LINKER "${linker}"
)
endfunction()
function(corrosion_set_hostbuild target_name)
# Configure the target to be compiled for the Host target and ignore any cross-compile configuration.
set_property(
TARGET ${target_name}
PROPERTY ${_CORR_PROP_HOST_BUILD} 1
)
endfunction()
# Add flags for rustc (RUSTFLAGS) which affect the target and all of it's Rust dependencies
#
# Additional rustflags may be passed as optional parameters after rustflag.
# Please note, that if you import multiple targets from a package or workspace, but set different
# Rustflags via this function, the Rust dependencies will have to be rebuilt when changing targets.
# Consider `corrosion_add_target_local_rustflags()` as an alternative to avoid this.
function(corrosion_add_target_rustflags target_name rustflag)
# Additional rustflags may be passed as optional parameters after rustflag.
set_property(
TARGET ${target_name}
APPEND
PROPERTY INTERFACE_CORROSION_RUSTFLAGS ${rustflag} ${ARGN}
)
endfunction()
# Add flags for rustc (RUSTFLAGS) which only affect the target, but none of it's (Rust) dependencies
#
# Additional rustflags may be passed as optional parameters after rustc_flag.
function(corrosion_add_target_local_rustflags target_name rustc_flag)
# Set Rustflags via `cargo rustc` which only affect the current crate, but not dependencies.
set_property(
TARGET ${target_name}
APPEND
PROPERTY INTERFACE_CORROSION_LOCAL_RUSTFLAGS ${rustc_flag} ${ARGN}
)
endfunction()
function(corrosion_set_env_vars target_name env_var)
# Additional environment variables may be passed as optional parameters after env_var.
set_property(
TARGET ${target_name}
APPEND
PROPERTY ${_CORR_PROP_ENV_VARS} ${env_var} ${ARGN}
)
endfunction()
function(corrosion_set_cargo_flags target_name)
# corrosion_set_cargo_flags(<target_name> [<flag1> ... ])
set_property(
TARGET ${target_name}
APPEND
PROPERTY INTERFACE_CORROSION_CARGO_FLAGS ${ARGN}
)
endfunction()
function(corrosion_set_features target_name)
# corrosion_set_features(<target_name> [ALL_FEATURES=Bool] [NO_DEFAULT_FEATURES] [FEATURES <feature1> ... ])
set(options NO_DEFAULT_FEATURES)
set(one_value_args ALL_FEATURES)
set(multi_value_args FEATURES)
cmake_parse_arguments(
PARSE_ARGV 1
SET
"${options}"
"${one_value_args}"
"${multi_value_args}"
)
if(DEFINED SET_ALL_FEATURES)
set_property(
TARGET ${target_name}
PROPERTY ${_CORR_PROP_ALL_FEATURES} ${SET_ALL_FEATURES}
)
endif()
if(SET_NO_DEFAULT_FEATURES)
set_property(
TARGET ${target_name}
PROPERTY ${_CORR_PROP_NO_DEFAULT_FEATURES} 1
)
endif()
if(SET_FEATURES)
set_property(
TARGET ${target_name}
APPEND
PROPERTY ${_CORR_PROP_FEATURES} ${SET_FEATURES}
)
endif()
endfunction()
function(corrosion_link_libraries target_name)
if(TARGET "${target_name}-static")
message(DEBUG "The target ${target_name} builds a static Rust library."
"Calling `target_link_libraries()` instead."
)
target_link_libraries("${target_name}-static" INTERFACE ${ARGN})
if(NOT TARGET "${target_name}-shared")
# Early return, since Rust won't invoke the linker for static libraries
return()
endif()
endif()
add_dependencies(_cargo-build_${target_name} ${ARGN})
foreach(library ${ARGN})
set_property(
TARGET _cargo-build_${target_name}
APPEND
PROPERTY CARGO_DEPS_LINKER_LANGUAGES
$<TARGET_PROPERTY:${library},LINKER_LANGUAGE>
)
corrosion_add_target_local_rustflags(${target_name} "-L$<TARGET_LINKER_FILE_DIR:${library}>")
corrosion_add_target_local_rustflags(${target_name} "-l$<TARGET_LINKER_FILE_BASE_NAME:${library}>")
endforeach()
endfunction()
function(corrosion_install)
# Default install dirs
include(GNUInstallDirs)
# Parse arguments to corrosion_install
list(GET ARGN 0 INSTALL_TYPE)
list(REMOVE_AT ARGN 0)
# The different install types that are supported. Some targets may have more than one of these
# types. For example, on Windows, a shared library will have both an ARCHIVE component and a
# RUNTIME component.
set(INSTALL_TARGET_TYPES ARCHIVE LIBRARY RUNTIME PRIVATE_HEADER PUBLIC_HEADER)
# Arguments to each install target type
set(OPTIONS)
set(ONE_VALUE_ARGS DESTINATION)
set(MULTI_VALUE_ARGS PERMISSIONS CONFIGURATIONS)
set(TARGET_ARGS ${OPTIONS} ${ONE_VALUE_ARGS} ${MULTI_VALUE_ARGS})
if (INSTALL_TYPE STREQUAL "TARGETS")
# corrosion_install(TARGETS ... [EXPORT <export-name>]
# [[ARCHIVE|LIBRARY|RUNTIME|PRIVATE_HEADER|PUBLIC_HEADER]
# [DESTINATION <dir>]
# [PERMISSIONS permissions...]
# [CONFIGURATIONS [Debug|Release|...]]
# ] [...])
# Extract targets
set(INSTALL_TARGETS)
list(LENGTH ARGN ARGN_LENGTH)
set(DELIMITERS EXPORT ${INSTALL_TARGET_TYPES} ${TARGET_ARGS})
while(ARGN_LENGTH)
# If we hit another keyword, stop - we've found all the targets
list(GET ARGN 0 FRONT)
if (FRONT IN_LIST DELIMITERS)
break()
endif()
list(APPEND INSTALL_TARGETS ${FRONT})
list(REMOVE_AT ARGN 0)
# Update ARGN_LENGTH
list(LENGTH ARGN ARGN_LENGTH)
endwhile()
# Check if there are any args left before proceeding
list(LENGTH ARGN ARGN_LENGTH)
if (ARGN_LENGTH)
list(GET ARGN 0 FRONT)
if (FRONT STREQUAL "EXPORT")
list(REMOVE_AT ARGN 0) # Pop "EXPORT"
list(GET ARGN 0 EXPORT_NAME)
list(REMOVE_AT ARGN 0) # Pop <export-name>
message(FATAL_ERROR "EXPORT keyword not yet implemented!")
endif()
endif()
# Loop over all arguments and get options for each install target type
list(LENGTH ARGN ARGN_LENGTH)
while(ARGN_LENGTH)
# Check if we're dealing with arguments for a specific install target type, or with
# default options for all target types.
list(GET ARGN 0 FRONT)
if (FRONT IN_LIST INSTALL_TARGET_TYPES)
set(INSTALL_TARGET_TYPE ${FRONT})
list(REMOVE_AT ARGN 0)
else()
set(INSTALL_TARGET_TYPE DEFAULT)
endif()
# Gather the arguments to this install type
set(ARGS)
while(ARGN_LENGTH)
# If the next keyword is an install target type, then break - arguments have been
# gathered.
list(GET ARGN 0 FRONT)
if (FRONT IN_LIST INSTALL_TARGET_TYPES)
break()
endif()
list(APPEND ARGS ${FRONT})
list(REMOVE_AT ARGN 0)
list(LENGTH ARGN ARGN_LENGTH)
endwhile()
# Parse the arguments and register the file install
cmake_parse_arguments(
COR "${OPTIONS}" "${ONE_VALUE_ARGS}" "${MULTI_VALUE_ARGS}" ${ARGS})
if (COR_DESTINATION)
set(COR_INSTALL_${INSTALL_TARGET_TYPE}_DESTINATION ${COR_DESTINATION})
endif()
if (COR_PERMISSIONS)
set(COR_INSTALL_${INSTALL_TARGET_TYPE}_PERMISSIONS ${COR_PERMISSIONS})
endif()
if (COR_CONFIGURATIONS)
set(COR_INSTALL_${INSTALL_TARGET_TYPE}_CONFIGURATIONS ${COR_CONFIGURATIONS})
endif()
# Update ARG_LENGTH
list(LENGTH ARGN ARGN_LENGTH)
endwhile()
# Default permissions for all files
set(DEFAULT_PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ)
# Loop through each install target and register file installations
foreach(INSTALL_TARGET ${INSTALL_TARGETS})
# Don't both implementing target type differentiation using generator expressions since
# TYPE cannot change after target creation
get_property(
TARGET_TYPE
TARGET ${INSTALL_TARGET} PROPERTY TYPE
)
# Install executable files first
if (TARGET_TYPE STREQUAL "EXECUTABLE")
if (DEFINED COR_INSTALL_RUNTIME_DESTINATION)
set(DESTINATION ${COR_INSTALL_RUNTIME_DESTINATION})
elseif (DEFINED COR_INSTALL_DEFAULT_DESTINATION)
set(DESTINATION ${COR_INSTALL_DEFAULT_DESTINATION})
else()
set(DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()
if (DEFINED COR_INSTALL_RUNTIME_PERMISSIONS)
set(PERMISSIONS ${COR_INSTALL_RUNTIME_PERMISSIONS})
elseif (DEFINED COR_INSTALL_DEFAULT_PERMISSIONS)
set(PERMISSIONS ${COR_INSTALL_DEFAULT_PERMISSIONS})
else()
set(
PERMISSIONS
${DEFAULT_PERMISSIONS} OWNER_EXECUTE GROUP_EXECUTE WORLD_EXECUTE)
endif()
if (DEFINED COR_INSTALL_RUNTIME_CONFIGURATIONS)
set(CONFIGURATIONS CONFIGURATIONS ${COR_INSTALL_RUNTIME_CONFIGURATIONS})
elseif (DEFINED COR_INSTALL_DEFAULT_CONFIGURATIONS)
set(CONFIGURATIONS CONFIGURATIONS ${COR_INSTALL_DEFAULT_CONFIGURATIONS})
else()
set(CONFIGURATIONS)
endif()
install(
FILES $<TARGET_FILE:${INSTALL_TARGET}>
DESTINATION ${DESTINATION}
PERMISSIONS ${PERMISSIONS}
${CONFIGURATIONS}
)
endif()
endforeach()
elseif(INSTALL_TYPE STREQUAL "EXPORT")
message(FATAL_ERROR "install(EXPORT ...) not yet implemented")
endif()
endfunction()
#[=======================================================================[.md:
** EXPERIMENTAL **: This function is currently still considered experimental
and is not officially released yet. Feedback and Suggestions are welcome.
ANCHOR: corrosion_add_cxxbridge
```cmake
corrosion_add_cxxbridge(cxx_target
CRATE <imported_target_name>
[FILES <file1.rs> <file2.rs>]
)
```
Adds build-rules to create C++ bindings using the [cxx] crate.
### Arguments:
* `cxxtarget`: Name of the C++ library target for the bindings, which corrosion will create.
* **FILES**: Input Rust source file containing #[cxx::bridge].
* **CRATE**: Name of an imported Rust target. Note: Parameter may be renamed before release
#### Currently missing arguments
The following arguments to cxxbridge **currently** have no way to be passed by the user:
- `--cfg`
- `--cxx-impl-annotations`
- `--include`
The created rules approximately do the following:
- Check which version of `cxx` the Rust crate specified by the `CRATE` argument depends on.
- Check if the exact same version of `cxxbridge-cmd` is installed (available in `PATH`)
- If not, create a rule to build the exact same version of `cxxbridge-cmd`.
- Create rules to run `cxxbridge` and generate
- The `rust/cxx.h` header
- A header and source file for each of the files specified in `FILES`
- The generated sources (and header include directories) are added to the `cxxtarget` CMake
library target.
### Limitations
We currently require the `CRATE` argument to be a target imported by Corrosion, however,
Corrosion does not import `rlib` only libraries. As a workaround users can add
`staticlib` to their list of crate kinds. In the future this may be solved more properly,
by either adding an option to also import Rlib targets (without build rules) or by
adding a `MANIFEST_PATH` argument to this function, specifying where the crate is.
### Contributing
Specifically some more realistic test / demo projects and feedback about limitations would be
welcome.
[cxx]: https://github.com/dtolnay/cxx
ANCHOR_END: corrosion_add_cxxbridge
#]=======================================================================]
function(corrosion_add_cxxbridge cxx_target)
set(OPTIONS)
set(ONE_VALUE_KEYWORDS CRATE)
set(MULTI_VALUE_KEYWORDS FILES)
cmake_parse_arguments(PARSE_ARGV 1 _arg "${OPTIONS}" "${ONE_VALUE_KEYWORDS}" "${MULTI_VALUE_KEYWORDS}")
set(required_keywords CRATE FILES)
foreach(keyword ${required_keywords})
if(NOT DEFINED "_arg_${keyword}")
message(FATAL_ERROR "Missing required parameter `${keyword}`.")
elseif("${_arg_${keyword}}" STREQUAL "")
message(FATAL_ERROR "Required parameter `${keyword}` may not be set to an empty string.")
endif()
endforeach()
get_target_property(manifest_path "${_arg_CRATE}" INTERFACE_COR_PACKAGE_MANIFEST_PATH)
if(NOT EXISTS "${manifest_path}")
message(FATAL_ERROR "Internal error: No package manifest found at ${manifest_path}")
endif()
get_filename_component(manifest_dir ${manifest_path} DIRECTORY)
execute_process(COMMAND ${CMAKE_COMMAND} -E env
"CARGO_BUILD_RUSTC=${_CORROSION_RUSTC}"
${_CORROSION_CARGO} tree -i cxx --depth=0
WORKING_DIRECTORY "${manifest_dir}"
RESULT_VARIABLE cxx_version_result
OUTPUT_VARIABLE cxx_version_output
)
if(NOT "${cxx_version_result}" EQUAL "0")
message(FATAL_ERROR "Crate ${_arg_CRATE} does not depend on cxx.")
endif()
if(cxx_version_output MATCHES "cxx v([0-9]+.[0-9]+.[0-9]+)")
set(cxx_required_version "${CMAKE_MATCH_1}")
else()
message(FATAL_ERROR "Failed to parse cxx version from cargo tree output: `cxx_version_output`")
endif()
# First check if a suitable version of cxxbridge is installed
find_program(INSTALLED_CXXBRIDGE cxxbridge PATHS "$ENV{HOME}/.cargo/bin/")
mark_as_advanced(INSTALLED_CXXBRIDGE)
if(INSTALLED_CXXBRIDGE)
execute_process(COMMAND ${INSTALLED_CXXBRIDGE} --version OUTPUT_VARIABLE cxxbridge_version_output)
if(cxxbridge_version_output MATCHES "cxxbridge ([0-9]+.[0-9]+.[0-9]+)")
set(cxxbridge_version "${CMAKE_MATCH_1}")
else()
set(cxxbridge_version "")
endif()
endif()
set(cxxbridge "")
if(cxxbridge_version)
if(cxxbridge_version VERSION_EQUAL cxx_required_version)
set(cxxbridge "${INSTALLED_CXXBRIDGE}")
if(NOT TARGET "cxxbridge_v${cxx_required_version}")
# Add an empty target.
add_custom_target("cxxbridge_v${cxx_required_version}"
)
endif()
endif()
endif()
# No suitable version of cxxbridge was installed, so use custom target to build correct version.
if(NOT cxxbridge)
if(NOT TARGET "cxxbridge_v${cxx_required_version}")
add_custom_command(OUTPUT "${CMAKE_BINARY_DIR}/corrosion/cxxbridge_v${cxx_required_version}/bin/cxxbridge"
COMMAND
${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/corrosion/cxxbridge_v${cxx_required_version}"
COMMAND
${CMAKE_COMMAND} -E env
"CARGO_BUILD_RUSTC=${_CORROSION_RUSTC}"
${_CORROSION_CARGO} install
cxxbridge-cmd
--version "${cxx_required_version}"
--root "${CMAKE_BINARY_DIR}/corrosion/cxxbridge_v${cxx_required_version}"
--quiet
# todo: use --target-dir to potentially reuse artifacts
COMMENT "Building cxxbridge (version ${cxx_required_version})"
)
add_custom_target("cxxbridge_v${cxx_required_version}"
DEPENDS "${CMAKE_BINARY_DIR}/corrosion/cxxbridge_v${cxx_required_version}/bin/cxxbridge"
)
endif()
set(cxxbridge "${CMAKE_BINARY_DIR}/corrosion/cxxbridge_v${cxx_required_version}/bin/cxxbridge")
endif()
# The generated folder structure will be of the following form
#
# CMAKE_CURRENT_BINARY_DIR
# corrosion_generated
# cxxbridge
# <cxx_target>
# include
# <cxx_target>
# <headers>
# rust
# cxx.h
# src
# <sourcefiles>
# cbindgen
# ...
# other
# ...
set(corrosion_generated_dir "${CMAKE_CURRENT_BINARY_DIR}/corrosion_generated")
set(generated_dir "${corrosion_generated_dir}/cxxbridge/${cxx_target}")
set(header_placement_dir "${generated_dir}/include/${cxx_target}")
set(source_placement_dir "${generated_dir}/src")
add_library(${cxx_target} STATIC)
target_include_directories(${cxx_target}
PUBLIC
$<BUILD_INTERFACE:${generated_dir}/include>
$<INSTALL_INTERFACE:include>
)
# cxx generated code is using c++11 features in headers, so propagate c++11 as minimal requirement
target_compile_features(${cxx_target} PUBLIC cxx_std_11)
# Todo: target_link_libraries is only necessary for rust2c projects.
# It is possible that checking if the rust crate is an executable is a sufficient check,
# but some more thought may be needed here.
# Maybe we should also let the user do this, since for c2rust, the user also has to call
# corrosion_link_libraries() themselves.
get_target_property(crate_target_type ${_arg_CRATE} TYPE)
if (NOT crate_target_type STREQUAL "EXECUTABLE")
target_link_libraries(${cxx_target} PRIVATE ${_arg_CRATE})
endif()
file(MAKE_DIRECTORY "${generated_dir}/include/rust")
add_custom_command(
OUTPUT "${generated_dir}/include/rust/cxx.h"
COMMAND
${cxxbridge} --header --output "${generated_dir}/include/rust/cxx.h"
DEPENDS "cxxbridge_v${cxx_required_version}"
COMMENT "Generating rust/cxx.h header"
)
foreach(filepath ${_arg_FILES})
get_filename_component(filename ${filepath} NAME_WE)
get_filename_component(directory ${filepath} DIRECTORY)
set(directory_component "")
if(directory)
set(directory_component "${directory}/")
endif()
# todo: convert potentially absolute paths to relative paths..
set(cxx_header ${directory_component}${filename}.h)
set(cxx_source ${directory_component}${filename}.cpp)
# todo: not all projects may use the `src` directory.
set(rust_source_path "${manifest_dir}/src/${filepath}")
file(MAKE_DIRECTORY "${header_placement_dir}/${directory}" "${source_placement_dir}/${directory}")
add_custom_command(
OUTPUT
"${header_placement_dir}/${cxx_header}"
"${source_placement_dir}/${cxx_source}"
COMMAND
${cxxbridge} ${rust_source_path} --header --output "${header_placement_dir}/${cxx_header}"
COMMAND
${cxxbridge} ${rust_source_path}
--output "${source_placement_dir}/${cxx_source}"
--include "${cxx_target}/${cxx_header}"
DEPENDS "cxxbridge_v${cxx_required_version}" "${rust_source_path}"
COMMENT "Generating cxx bindings for crate ${_arg_CRATE}"
)
target_sources(${cxx_target}
PRIVATE
"${header_placement_dir}/${cxx_header}"
"${generated_dir}/include/rust/cxx.h"
"${source_placement_dir}/${cxx_source}"
)
endforeach()
endfunction()
#[=======================================================================[.md:
ANCHOR: corrosion_cbindgen
```cmake
corrosion_cbindgen(
TARGET <imported_target_name>
HEADER_NAME <output_header_name>
[MANIFEST_DIRECTORY <package_manifest_directory>]
[CBINDGEN_VERSION <version>]
[FLAGS <flag1> ... <flagN>]
)
```
A helper function which uses [cbindgen] to generate C/C++ bindings for a Rust crate.
If `cbindgen` is not in `PATH` the helper function will automatically try to download
`cbindgen` and place the built binary into `CMAKE_BINARY_DIR`. The binary is shared
between multiple invocations of this function.
* **TARGET**: The name of an imported Rust library target (crate), for which bindings should be generated.
If the target was not previously imported by Corrosion, because the crate only produces an
`rlib`, you must additionally specify `MANIFEST_DIRECTORY`.
* **MANIFEST_DIRECTORY**: Directory of the package defining the library crate bindings should be generated for.
If you want to avoid specifying `MANIFEST_DIRECTORY` you could add a `staticlib` target to your package
manifest as a workaround to make corrosion import the crate.
* **HEADER_NAME**: The name of the generated header file. This will be the name which you include in your C/C++ code
(e.g. `#include "myproject/myheader.h" if you specify `HEADER_NAME "myproject/myheader.h"`.
* **CBINDGEN_VERSION**: Version requirement for cbindgen. Exact semantics to be specified. Currently not implemented.
* **FLAGS**: Arbitrary other flags for `cbindgen`. Run `cbindgen --help` to see the possible flags.
[cbindgen]: https://github.com/eqrion/cbindgen
ANCHOR_END: corrosion_cbindgen
#]=======================================================================]
function(corrosion_experimental_cbindgen)
set(OPTIONS "")
set(ONE_VALUE_KEYWORDS TARGET MANIFEST_DIRECTORY HEADER_NAME CBINDGEN_VERSION)
set(MULTI_VALUE_KEYWORDS "FLAGS")
cmake_parse_arguments(PARSE_ARGV 0 CCN "${OPTIONS}" "${ONE_VALUE_KEYWORDS}" "${MULTI_VALUE_KEYWORDS}")
set(required_keywords TARGET HEADER_NAME)
foreach(keyword ${required_keywords})
if(NOT DEFINED "CCN_${keyword}")
message(FATAL_ERROR "Missing required parameter `${keyword}`.")
elseif("${CCN_${keyword}}" STREQUAL "")
message(FATAL_ERROR "Required parameter `${keyword}` may not be set to an empty string.")
endif()
endforeach()
set(rust_target "${CCN_TARGET}")
unset(package_manifest_dir)
set(hostbuild_override "$<BOOL:$<TARGET_PROPERTY:${rust_target},${_CORR_PROP_HOST_BUILD}>>")
set(cbindgen_target_triple "$<IF:${hostbuild_override},${_CORROSION_RUST_CARGO_HOST_TARGET},${_CORROSION_RUST_CARGO_TARGET}>")
if(TARGET "${rust_target}")
get_target_property(package_manifest_path "${rust_target}" INTERFACE_COR_PACKAGE_MANIFEST_PATH)
if(NOT EXISTS "${package_manifest_path}")
message(FATAL_ERROR "Internal error: No package manifest found at ${package_manifest_path}")
endif()
get_filename_component(package_manifest_dir "${package_manifest_path}" DIRECTORY)
# todo: as an optimization we could cache the cargo metadata output (but --no-deps makes that slightly more complicated)
else()
if(NOT DEFINED CCN_MANIFEST_DIRECTORY)
message(FATAL_ERROR
"`${rust_target}` is not a target imported by corrosion and `MANIFEST_DIRECTORY` was not provided."
)
else()
set(package_manifest_dir "${CCN_MANIFEST_DIRECTORY}")
endif()
endif()
unset(rust_cargo_package)
if(NOT DEFINED CCN_CARGO_PACKAGE)
get_target_property(rust_cargo_package "${rust_target}" INTERFACE_COR_CARGO_PACKAGE_NAME )
if(NOT rust_cargo_package)
message(FATAL_ERROR "Could not determine cargo package name for cbindgen!")
endif()
else()
set(rust_cargo_package "${CCN_CARGO_PACKAGE}")
endif()
message(STATUS "Using package ${rust_cargo_package} as crate for cbindgen")
set(output_header_name "${CCN_HEADER_NAME}")
find_program(installed_cbindgen cbindgen)
# Install the newest cbindgen version into our build tree.
if(installed_cbindgen)
set(cbindgen "${installed_cbindgen}")
else()
set(local_cbindgen_install_dir "${CMAKE_BINARY_DIR}/corrosion/cbindgen")
unset(executable_postfix)
if(Rust_CARGO_HOST_OS STREQUAL "windows")
set(executable_postfix ".exe")
endif()
set(cbindgen "${local_cbindgen_install_dir}/bin/cbindgen${executable_postfix}")
if(NOT TARGET "_corrosion_cbindgen")
file(MAKE_DIRECTORY "${local_cbindgen_install_dir}")
add_custom_command(OUTPUT "${cbindgen}"
COMMAND ${CMAKE_COMMAND}
-E env
"CARGO_BUILD_RUSTC=${_CORROSION_RUSTC}"
${_CORROSION_CARGO} install
cbindgen
--root "${local_cbindgen_install_dir}"
${_CORROSION_QUIET_OUTPUT_FLAG}
COMMENT "Building cbindgen"
)
add_custom_target("_corrosion_cbindgen"
DEPENDS "${cbindgen}"
)
endif()
endif()
set(corrosion_generated_dir "${CMAKE_CURRENT_BINARY_DIR}/corrosion_generated")
set(generated_dir "${corrosion_generated_dir}/cbindgen/${rust_target}")
set(header_placement_dir "${generated_dir}/include/")
set(depfile_placement_dir "${generated_dir}/depfile")
set(generated_depfile "${depfile_placement_dir}/${output_header_name}.d")
set(generated_header "${header_placement_dir}/${output_header_name}")
message(STATUS "rust target is ${rust_target}")
if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.23")
target_sources(${rust_target}
INTERFACE
FILE_SET HEADERS
BASE_DIRS "${header_placement_dir}"
FILES "${header_placement_dir}/${output_header_name}"
)
else()
# Note: not clear to me how install would best work before CMake 3.23
target_include_directories(${rust_target}
INTERFACE
$<BUILD_INTERFACE:${header_placement_dir}>
$<INSTALL_INTERFACE:include>
)
endif()
# This may be different from $header_placement_dir since the user specified HEADER_NAME may contain
# relative directories.
get_filename_component(generated_header_dir "${generated_header}" DIRECTORY)
file(MAKE_DIRECTORY "${generated_header_dir}")
unset(depfile_cbindgen_arg)
unset(depfile_cmake_arg)
get_filename_component(generated_depfile_dir "${generated_depfile}" DIRECTORY)
file(MAKE_DIRECTORY "${generated_depfile_dir}")
set(depfile_cbindgen_arg "--depfile=${generated_depfile}")
# Users might want to call cbindgen multiple times, e.g. to generate separate C++ and C header files.
string(MAKE_C_IDENTIFIER "${output_header_name}" header_identifier )
if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.22")
add_custom_command(
OUTPUT
"${generated_header}"
COMMAND
"${CMAKE_COMMAND}" -E env
TARGET="${cbindgen_target_triple}"
"${cbindgen}"
--output "${generated_header}"
--crate "${rust_cargo_package}"
${depfile_cbindgen_arg}
${CCN_FLAGS}
COMMENT "Generate cbindgen bindings for package ${rust_cargo_package} and output header ${generated_header}"
DEPFILE "${generated_depfile}"
COMMAND_EXPAND_LISTS
WORKING_DIRECTORY "${package_manifest_dir}"
)
add_custom_target("_corrosion_cbindgen_${rust_target}_bindings_${header_identifier}"
DEPENDS "${generated_header}"
COMMENT "Generate ${generated_header} for ${rust_target}"
)
else()
add_custom_target("_corrosion_cbindgen_${rust_target}_bindings_${header_identifier}"
"${CMAKE_COMMAND}" -E env
TARGET="${cbindgen_target_triple}"
"${cbindgen}"
--output "${generated_header}"
--crate "${rust_cargo_package}"
${depfile_cbindgen_arg}
${CCN_FLAGS}
COMMENT "Generate ${generated_header} for ${rust_target}"
COMMAND_EXPAND_LISTS
WORKING_DIRECTORY "${package_manifest_dir}"
)
endif()
if(NOT installed_cbindgen)
add_custom_command(
OUTPUT "${generated_header}"
APPEND
DEPENDS _corrosion_cbindgen
)
endif()
if(NOT TARGET "_corrosion_cbindgen_${rust_target}_bindings")
add_custom_target(_corrosion_cbindgen_${rust_target}_bindings
COMMENT "Generate cbindgen bindings for package ${rust_cargo_package}"
)
endif()
add_dependencies("_corrosion_cbindgen_${rust_target}_bindings" "_corrosion_cbindgen_${rust_target}_bindings_${header_identifier}")
add_dependencies(${rust_target} "_corrosion_cbindgen_${rust_target}_bindings")
endfunction()
# Parse the version of a Rust package from it's package manifest (Cargo.toml)
function(corrosion_parse_package_version package_manifest_path out_package_version)
if(NOT EXISTS "${package_manifest_path}")
message(FATAL_ERROR "Package manifest `${package_manifest_path}` does not exist.")
endif()
file(READ "${package_manifest_path}" package_manifest)
# Find the package table. It may contain arrays, so match until \n\[, which should mark the next
# table. Note: backslashes must be doubled to escape the backslash for the bracket. LF is single
# backslash however. On windows the line also ends in \n, so matching against \n\[ is sufficient
# to detect an opening bracket on a new line.
set(package_table_regex "\\[package\\](.*)\n\\[")
string(REGEX MATCH "${package_table_regex}" _package_table "${package_manifest}")
if(CMAKE_MATCH_COUNT EQUAL "1")
set(package_table "${CMAKE_MATCH_1}")
else()
message(DEBUG
"Failed to find `[package]` table in package manifest `${package_manifest_path}`.\n"
"Matches: ${CMAKE_MATCH_COUNT}\n"
)
set(${out_package_version}
"NOTFOUND"
PARENT_SCOPE
)
endif()
# Match `version = "0.3.2"`, `"version" = "0.3.2" Contains one matching group for the version
set(version_regex "[\r]?\n[\"']?version[\"']?[ \t]*=[ \t]*[\"']([0-9\.]+)[\"']")
string(REGEX MATCH "${version_regex}" _version "${package_table}")
if("${package_table}" MATCHES "${version_regex}")
set(${out_package_version}
"${CMAKE_MATCH_1}"
PARENT_SCOPE
)
else()
message(DEBUG "Failed to extract package version from manifest `${package_manifest_path}`.")
set(${out_package_version}
"NOTFOUND"
PARENT_SCOPE
)
endif()
endfunction()
# Helper macro to pass through an optional `OPTION` argument parsed via `cmake_parse_arguments`
# to another function that takes the same OPTION.
# If the option was set, then the variable <var_name> will be set to the same option name again,
# otherwise <var_name> will be unset.
macro(_corrosion_option_passthrough_helper option_name prefix var_name)
if(${${prefix}_${option_name}})
set("${var_name}" "${option_name}")
else()
unset("${var_name}")
endif()
endmacro()
# Helper macro to pass through an optional argument with value(s), parsed via `cmake_parse_arguments`,
# to another function that takes the same keyword + associated values.
# If the argument was given, then the variable <var_name> will be a list of the argument name and the values,
# which will be expanded, when calling the function (assuming no quotes).
macro(_corrosion_arg_passthrough_helper arg_name prefix var_name)
if(DEFINED "${prefix}_${arg_name}")
set("${var_name}" "${arg_name}" "${${prefix}_${arg_name}}")
else()
unset("${var_name}")
endif()
endmacro()
list(POP_BACK CMAKE_MESSAGE_CONTEXT)