blob: 401029b03e2036fa6317686dd3c741324e7ca40c [file] [log] [blame]
# Copyright 2020 The Pigweed Authors
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations under
# the License.
include_guard(GLOBAL)
cmake_minimum_required(VERSION 3.19)
# The PW_ROOT environment variable should be set in bootstrap. If it is not set,
# set it to the root of the Pigweed repository.
if("$ENV{PW_ROOT}" STREQUAL "")
get_filename_component(pw_root "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
message("The PW_ROOT environment variable is not set; "
"using ${pw_root} within CMake")
set(ENV{PW_ROOT} "${pw_root}")
endif()
# Wrapper around cmake_parse_arguments that fails with an error if any arguments
# remained unparsed.
macro(pw_parse_arguments_strict function start_arg options one multi)
cmake_parse_arguments(PARSE_ARGV
"${start_arg}" arg "${options}" "${one}" "${multi}"
)
if(NOT "${arg_UNPARSED_ARGUMENTS}" STREQUAL "")
set(_all_args ${options} ${one} ${multi})
message(FATAL_ERROR
"Unexpected arguments to ${function}: ${arg_UNPARSED_ARGUMENTS}\n"
"Valid arguments: ${_all_args}"
)
endif()
endmacro()
# Checks that one or more variables are set. This is used to check that
# arguments were provided to a function. Fails with FATAL_ERROR if
# ${ARG_PREFIX}${name} is empty. The FUNCTION_NAME is used in the error message.
# If FUNCTION_NAME is "", it is set to CMAKE_CURRENT_FUNCTION.
#
# Usage:
#
# pw_require_args(FUNCTION_NAME ARG_PREFIX ARG_NAME [ARG_NAME ...])
#
# Examples:
#
# # Checks that arg_FOO is non-empty, using the current function name.
# pw_require_args("" arg_ FOO)
#
# # Checks that FOO and BAR are non-empty, using function name "do_the_thing".
# pw_require_args(do_the_thing "" FOO BAR)
#
macro(pw_require_args FUNCTION_NAME ARG_PREFIX)
if("${FUNCTION_NAME}" STREQUAL "")
set(_pw_require_args_FUNCTION_NAME "${CMAKE_CURRENT_FUNCTION}")
else()
set(_pw_require_args_FUNCTION_NAME "${FUNCTION_NAME}")
endif()
foreach(name IN ITEMS ${ARGN})
if("${${ARG_PREFIX}${name}}" STREQUAL "")
message(FATAL_ERROR "A value must be provided for ${name} in "
"${_pw_require_args_FUNCTION_NAME}.")
endif()
endforeach()
endmacro()
# Automatically creates a library and test targets for the files in a module.
# This function is only suitable for simple modules that meet the following
# requirements:
#
# - The module exposes exactly one library.
# - All source files in the module directory are included in the library.
# - Each test in the module has
# - exactly one source .cc file,
# - optionally, one .c source with the same base name as the .cc file,
# - only a dependency on the main module library.
# - The module is not a facade.
#
# Modules that do not meet these requirements may not use
# pw_auto_add_simple_module. Instead, define the module's libraries and tests
# with pw_add_module_library, pw_add_facade, pw_add_test, and the standard CMake
# functions, such as add_library, target_link_libraries, etc.
#
# This function does the following:
#
# 1. Find all .c and .cc files in the module's root directory.
# 2. Create a library with the module name using pw_add_module_library with
# all source files that do not end with _test.cc.
# 3. Declare a test for each source file that ends with _test.cc.
#
# Args:
#
# IMPLEMENTS_FACADE - this module implements the specified facade
# PUBLIC_DEPS - public pw_target_link_targets arguments
# PRIVATE_DEPS - private pw_target_link_targets arguments
#
function(pw_auto_add_simple_module MODULE)
pw_parse_arguments_strict(pw_auto_add_simple_module 1
""
"IMPLEMENTS_FACADE"
"PUBLIC_DEPS;PRIVATE_DEPS;TEST_DEPS"
)
file(GLOB all_sources *.cc *.c)
# Create a library with all source files not ending in _test.
set(sources "${all_sources}")
list(FILTER sources EXCLUDE REGEX "_test(\\.cc|(_c)?\\.c)$") # *_test.cc
list(FILTER sources EXCLUDE REGEX "^test(\\.cc|(_c)?\\.c)$") # test.cc
list(FILTER sources EXCLUDE REGEX "_fuzzer\\.cc$")
file(GLOB_RECURSE headers *.h)
if(arg_IMPLEMENTS_FACADE)
set(groups backends)
else()
set(groups modules "${MODULE}")
endif()
pw_add_module_library("${MODULE}"
IMPLEMENTS_FACADES
${arg_IMPLEMENTS_FACADE}
PUBLIC_DEPS
${arg_PUBLIC_DEPS}
PRIVATE_DEPS
${arg_PRIVATE_DEPS}
SOURCES
${sources}
HEADERS
${headers}
)
pw_auto_add_module_tests("${MODULE}"
PRIVATE_DEPS
${arg_PUBLIC_DEPS}
${arg_PRIVATE_DEPS}
${arg_TEST_DEPS}
GROUPS
${groups}
)
endfunction(pw_auto_add_simple_module)
# Creates a test for each source file ending in _test. Tests with mutliple .cc
# files or different dependencies than the module will not work correctly.
#
# Args:
#
# PRIVATE_DEPS - dependencies to apply to all tests
# GROUPS - groups in addition to MODULE to which to add these tests
#
function(pw_auto_add_module_tests MODULE)
pw_parse_arguments_strict(pw_auto_add_module_tests 1
""
""
"PRIVATE_DEPS;GROUPS"
)
file(GLOB cc_tests *_test.cc)
foreach(test IN LISTS cc_tests)
get_filename_component(test_name "${test}" NAME_WE)
# Find a .c test corresponding with the test .cc file, if any.
file(GLOB c_test "${test_name}.c" "${test_name}_c.c")
pw_add_test("${MODULE}.${test_name}"
SOURCES
"${test}"
${c_test}
DEPS
"$<TARGET_NAME_IF_EXISTS:${MODULE}>"
${arg_PRIVATE_DEPS}
GROUPS
"${MODULE}"
${arg_GROUPS}
)
endforeach()
endfunction(pw_auto_add_module_tests)
# pw_target_link_targets: CMake target only form of target_link_libraries.
#
# Helper wrapper around target_link_libraries which only supports CMake targets
# and detects when the target does not exist.
#
# NOTE: Generator expressions are not supported.
#
# Due to the processing order of list files, the list of targets has to be
# checked at the end of the root CMake list file. Instead of requiring all
# list files to be modified, a DEFER CALL is used.
#
# Required Args:
#
# <name> - The library target to add the TARGET link dependencies to.
#
# Optional Args:
#
# INTERFACE - interface target_link_libraries arguments which are all TARGETs.
# PUBLIC - public target_link_libraries arguments which are all TARGETs.
# PRIVATE - private target_link_libraries arguments which are all TARGETs.
function(pw_target_link_targets NAME)
set(types INTERFACE PUBLIC PRIVATE )
set(num_positional_args 1)
set(option_args)
set(one_value_args)
set(multi_value_args ${types})
pw_parse_arguments_strict(
pw_target_link_targets "${num_positional_args}" "${option_args}"
"${one_value_args}" "${multi_value_args}")
if(NOT TARGET "${NAME}")
message(FATAL_ERROR "\"${NAME}\" must be a TARGET library")
endif()
foreach(type IN LISTS types)
foreach(library IN LISTS arg_${type})
target_link_libraries(${NAME} ${type} ${library})
if(NOT TARGET ${library})
# It's possible the target has not yet been defined due to the ordering
# of add_subdirectory. Ergo defer the call until the end of the
# configuration phase.
# cmake_language(DEFER ...) evaluates arguments at the time the deferred
# call is executed, ergo wrap it in a cmake_language(EVAL CODE ...) to
# evaluate the arguments now. The arguments are wrapped in brackets to
# avoid re-evaluation at the deferred call.
cmake_language(EVAL CODE
"cmake_language(DEFER DIRECTORY ${CMAKE_SOURCE_DIR} CALL
_pw_target_link_targets_deferred_check
[[${NAME}]] [[${type}]] ${library})"
)
endif()
endforeach()
endforeach()
endfunction()
# Runs any deferred library checks for pw_target_link_targets.
#
# Required Args:
#
# <name> - The name of the library target to add the link dependencies to.
# <type> - The type of the library (INTERFACE, PUBLIC, PRIVATE).
# <library> - The library to check to assert it's a TARGET.
function(_pw_target_link_targets_deferred_check NAME TYPE LIBRARY)
if(NOT TARGET ${LIBRARY})
message(FATAL_ERROR
"${NAME}'s ${TYPE} dep \"${LIBRARY}\" is not a target.")
endif()
endfunction()
# Sets the provided variable to the multi_value_keywords from pw_add_library.
macro(_pw_add_library_multi_value_args variable)
set("${variable}" SOURCES HEADERS
PUBLIC_DEPS PRIVATE_DEPS
PUBLIC_INCLUDES PRIVATE_INCLUDES
PUBLIC_DEFINES PRIVATE_DEFINES
PUBLIC_COMPILE_OPTIONS PRIVATE_COMPILE_OPTIONS
PUBLIC_LINK_OPTIONS PRIVATE_LINK_OPTIONS "${ARGN}")
endmacro()
# pw_add_library: Creates a CMake library target.
#
# Required Args:
#
# <name> - The name of the library target to be created.
# <type> - The library type which must be INTERFACE, OBJECT, STATIC, SHARED,
# or MODULE.
#
# Optional Args:
#
# SOURCES - source files for this library
# HEADERS - header files for this library
# PUBLIC_DEPS - public pw_target_link_targets arguments
# PRIVATE_DEPS - private pw_target_link_targets arguments
# PUBLIC_INCLUDES - public target_include_directories argument
# PRIVATE_INCLUDES - public target_include_directories argument
# PUBLIC_DEFINES - public target_compile_definitions arguments
# PRIVATE_DEFINES - private target_compile_definitions arguments
# PUBLIC_COMPILE_OPTIONS - public target_compile_options arguments
# PRIVATE_COMPILE_OPTIONS - private target_compile_options arguments
# PUBLIC_LINK_OPTIONS - public target_link_options arguments
# PRIVATE_LINK_OPTIONS - private target_link_options arguments
function(pw_add_library NAME TYPE)
set(num_positional_args 2)
set(option_args)
set(one_value_args)
_pw_add_library_multi_value_args(multi_value_args)
pw_parse_arguments_strict(
pw_add_library "${num_positional_args}" "${option_args}"
"${one_value_args}" "${multi_value_args}")
add_library("${NAME}" "${TYPE}" EXCLUDE_FROM_ALL)
# Instead of forking all of the code below or injecting an empty source file,
# conditionally select PUBLIC vs INTERFACE depending on the type.
if("${TYPE}" STREQUAL "INTERFACE")
set(public_or_interface INTERFACE)
if(NOT "${arg_SOURCES}" STREQUAL "")
message(
SEND_ERROR "${NAME} cannot have sources as it's an INTERFACE library")
endif(NOT "${arg_SOURCES}" STREQUAL "")
else() # ${TYPE} != INTERFACE
set(public_or_interface PUBLIC)
if("${arg_SOURCES}" STREQUAL "")
message(
SEND_ERROR "${NAME} must have SOURCES as it's not an INTERFACE library")
endif("${arg_SOURCES}" STREQUAL "")
endif("${TYPE}" STREQUAL "INTERFACE")
target_sources("${NAME}" PRIVATE ${arg_SOURCES} ${arg_HEADERS})
# CMake 3.22 does not have a notion of target_headers yet, so in the mean
# time we ask for headers to be specified for consistency with GN & Bazel and
# to improve the IDE experience. However, we do want to ensure all the headers
# which are otherwise ignored by CMake are present.
#
# See https://gitlab.kitware.com/cmake/cmake/-/issues/22468 for adding support
# to CMake to associate headers with targets properly for CMake 3.23.
foreach(header IN ITEMS ${arg_HEADERS})
get_filename_component(header "${header}" ABSOLUTE)
if(NOT EXISTS ${header})
message(FATAL_ERROR "Header not found: \"${header}\"")
endif()
endforeach()
# Public and private target_include_directories.
target_include_directories("${NAME}" PRIVATE ${arg_PRIVATE_INCLUDES})
target_include_directories(
"${NAME}" ${public_or_interface} ${arg_PUBLIC_INCLUDES})
# Public and private target_link_libraries.
if(NOT "${arg_SOURCES}" STREQUAL "")
pw_target_link_targets("${NAME}" PRIVATE ${arg_PRIVATE_DEPS})
endif(NOT "${arg_SOURCES}" STREQUAL "")
pw_target_link_targets("${NAME}" ${public_or_interface} ${arg_PUBLIC_DEPS})
# The target_compile_options are always added before target_link_libraries'
# target_compile_options. In order to support the enabling of warning
# compile options injected via arg_PRIVATE_DEPS (target_link_libraries
# dependencies) that are partially disabled via arg_PRIVATE_COMPILE_OPTIONS (
# target_compile_options), the defines, compile options, and link options are
# also added as target_link_libraries dependencies. This enables reasonable
# ordering between the enabling (target_link_libraries) and disabling (
# now also target_link_libraries) of compiler warnings.
# Add the NAME._config target_link_libraries dependency with the
# PRIVATE_DEFINES, PRIVATE_COMPILE_OPTIONS, and PRIVATE_LINK_OPTIONS.
if(NOT "${TYPE}" STREQUAL "INTERFACE")
pw_target_link_targets("${NAME}" PRIVATE "${NAME}._config")
add_library("${NAME}._config" INTERFACE EXCLUDE_FROM_ALL)
if(NOT "${arg_PRIVATE_DEFINES}" STREQUAL "")
target_compile_definitions(
"${NAME}._config" INTERFACE ${arg_PRIVATE_DEFINES})
endif(NOT "${arg_PRIVATE_DEFINES}" STREQUAL "")
if(NOT "${arg_PRIVATE_COMPILE_OPTIONS}" STREQUAL "")
target_compile_options(
"${NAME}._config" INTERFACE ${arg_PRIVATE_COMPILE_OPTIONS})
endif(NOT "${arg_PRIVATE_COMPILE_OPTIONS}" STREQUAL "")
if(NOT "${arg_PRIVATE_LINK_OPTIONS}" STREQUAL "")
target_link_options("${NAME}._config" INTERFACE ${arg_PRIVATE_LINK_OPTIONS})
endif(NOT "${arg_PRIVATE_LINK_OPTIONS}" STREQUAL "")
endif(NOT "${TYPE}" STREQUAL "INTERFACE")
# Add the NAME._public_config target_link_libraries dependency with the
# PUBLIC_DEFINES, PUBLIC_COMPILE_OPTIONS, and PUBLIC_LINK_OPTIONS.
add_library("${NAME}._public_config" INTERFACE EXCLUDE_FROM_ALL)
pw_target_link_targets(
"${NAME}" ${public_or_interface} "${NAME}._public_config")
if(NOT "${arg_PUBLIC_DEFINES}" STREQUAL "")
target_compile_definitions(
"${NAME}._public_config" INTERFACE ${arg_PUBLIC_DEFINES})
endif(NOT "${arg_PUBLIC_DEFINES}" STREQUAL "")
if(NOT "${arg_PUBLIC_COMPILE_OPTIONS}" STREQUAL "")
target_compile_options(
"${NAME}._public_config" INTERFACE ${arg_PUBLIC_COMPILE_OPTIONS})
endif(NOT "${arg_PUBLIC_COMPILE_OPTIONS}" STREQUAL "")
if(NOT "${arg_PUBLIC_LINK_OPTIONS}" STREQUAL "")
target_link_options(
"${NAME}._public_config" INTERFACE ${arg_PUBLIC_LINK_OPTIONS})
endif(NOT "${arg_PUBLIC_LINK_OPTIONS}" STREQUAL "")
endfunction(pw_add_library)
# Checks that the library's name is prefixed by the relative path with dot
# separators instead of forward slashes. Ignores paths not under the root
# directory.
#
# Optional Args:
#
# REMAP_PREFIXES - support remapping a prefix for checks
#
function(_pw_check_name_is_relative_to_root NAME ROOT)
pw_parse_arguments_strict(_pw_check_name_is_relative_to_root
2 "" "" "REMAP_PREFIXES")
file(RELATIVE_PATH rel_path "${ROOT}" "${CMAKE_CURRENT_SOURCE_DIR}")
if("${rel_path}" MATCHES "^\\.\\.")
return() # Ignore paths not under ROOT
endif()
list(LENGTH arg_REMAP_PREFIXES remap_arg_count)
if("${remap_arg_count}" EQUAL 2)
list(GET arg_REMAP_PREFIXES 0 from_prefix)
list(GET arg_REMAP_PREFIXES 1 to_prefix)
string(REGEX REPLACE "^${from_prefix}" "${to_prefix}" rel_path "${rel_path}")
elseif(NOT "${remap_arg_count}" EQUAL 0)
message(FATAL_ERROR
"If REMAP_PREFIXES is specified, exactly two arguments must be given.")
endif()
if(NOT "${rel_path}" MATCHES "^\\.\\..*")
string(REPLACE "/" "." dot_rel_path "${rel_path}")
if(NOT "${NAME}" MATCHES "^${dot_rel_path}(\\.[^\\.]+)?(\\.facade)?$")
message(FATAL_ERROR
"Module libraries under ${ROOT} must match the module name or be in "
"the form 'PATH_TO.THE_TARGET.NAME'. The library '${NAME}' does not "
"match. Expected ${dot_rel_path}.LIBRARY_NAME"
)
endif()
endif()
endfunction(_pw_check_name_is_relative_to_root)
# Creates a pw module library.
#
# Required Args:
#
# <name> - The name of the library target to be created.
#
# Optional Args:
#
# IMPLEMENTS_FACADES - which facades this module library implements
# SOURCES - source files for this library
# HEADERS - header files for this library
# PUBLIC_DEPS - public pw_target_link_targets arguments
# PRIVATE_DEPS - private pw_target_link_targets arguments
# PUBLIC_INCLUDES - public target_include_directories argument
# PRIVATE_INCLUDES - public target_include_directories argument
# PUBLIC_DEFINES - public target_compile_definitions arguments
# PRIVATE_DEFINES - private target_compile_definitions arguments
# PUBLIC_COMPILE_OPTIONS - public target_compile_options arguments
# PRIVATE_COMPILE_OPTIONS - private target_compile_options arguments
# PUBLIC_LINK_OPTIONS - public target_link_options arguments
# PRIVATE_LINK_OPTIONS - private target_link_options arguments
#
function(pw_add_module_library NAME)
_pw_add_library_multi_value_args(multi_value_args IMPLEMENTS_FACADES)
pw_parse_arguments_strict(pw_add_module_library 1 "" "" "${multi_value_args}")
_pw_check_name_is_relative_to_root("${NAME}" "$ENV{PW_ROOT}"
REMAP_PREFIXES
third_party pw_third_party
)
# Use STATIC libraries if sources are provided, else instantiate an INTERFACE
# library. Also conditionally select PUBLIC vs INTERFACE depending on this
# selection.
if(NOT "${arg_SOURCES}" STREQUAL "")
set(type STATIC)
set(public_or_interface PUBLIC)
else("${arg_SOURCES}" STREQUAL "")
set(type INTERFACE)
set(public_or_interface INTERFACE)
endif(NOT "${arg_SOURCES}" STREQUAL "")
pw_add_library(${NAME} ${type}
SOURCES
${arg_SOURCES}
HEADERS
${arg_HEADERS}
PUBLIC_DEPS
# TODO(b/232141950): Apply compilation options that affect ABI
# globally in the CMake build instead of injecting them into libraries.
pw_build
${arg_PUBLIC_DEPS}
PRIVATE_DEPS
pw_build.warnings
${arg_PRIVATE_DEPS}
PUBLIC_INCLUDES
${arg_PUBLIC_INCLUDES}
PRIVATE_INCLUDES
${arg_PRIVATE_INCLUDES}
PUBLIC_DEFINES
${arg_PUBLIC_DEFINES}
PRIVATE_DEFINES
${arg_PRIVATE_DEFINES}
PUBLIC_COMPILE_OPTIONS
${arg_PUBLIC_COMPILE_OPTIONS}
PRIVATE_COMPILE_OPTIONS
${arg_PRIVATE_COMPILE_OPTIONS}
PUBLIC_LINK_OPTIONS
${arg_PUBLIC_LINK_OPTIONS}
PRIVATE_LINK_OPTIONS
${arg_PRIVATE_LINK_OPTIONS}
)
# TODO(b/235273746): Deprecate this legacy implicit PUBLIC_INCLUDES.
if("${arg_PUBLIC_INCLUDES}" STREQUAL "")
target_include_directories("${NAME}" ${public_or_interface} public)
endif("${arg_PUBLIC_INCLUDES}" STREQUAL "")
if(NOT "${arg_IMPLEMENTS_FACADES}" STREQUAL "")
# TODO(b/235273746): Deprecate this legacy implicit PUBLIC_INCLUDES.
if("${arg_PUBLIC_INCLUDES}" STREQUAL "")
target_include_directories(
"${NAME}" ${public_or_interface} public_overrides)
endif("${arg_PUBLIC_INCLUDES}" STREQUAL "")
set(facades ${arg_IMPLEMENTS_FACADES})
list(TRANSFORM facades APPEND ".facade")
pw_target_link_targets("${NAME}" ${public_or_interface} ${facades})
endif(NOT "${arg_IMPLEMENTS_FACADES}" STREQUAL "")
endfunction(pw_add_module_library)
# Declares a module as a facade.
#
# Facades are declared as two libraries to avoid circular dependencies.
# Libraries that use the facade depend on a library named for the module. The
# module that implements the facade depends on a library named
# MODULE_NAME.facade.
#
# pw_add_facade accepts the same arguments as pw_add_module_library, except for
# IMPLEMENTS_FACADES. It also accepts the following argument:
#
# DEFAULT_BACKEND - which backend to use by default
#
function(pw_add_facade NAME)
_pw_add_library_multi_value_args(list_args)
pw_parse_arguments_strict(pw_add_facade 1 "" "DEFAULT_BACKEND" "${list_args}")
# If no backend is set, a script that displays an error message is used
# instead. If the facade is used in the build, it fails with this error.
add_custom_target("${NAME}._no_backend_set_message"
COMMAND
"${CMAKE_COMMAND}" -E echo
"ERROR: Attempted to build the ${NAME} facade with no backend."
"Configure the ${NAME} backend using pw_set_backend or remove all dependencies on it."
"See https://pigweed.dev/pw_build."
COMMAND
"${CMAKE_COMMAND}" -E false
)
add_library("${NAME}.NO_BACKEND_SET" INTERFACE)
add_dependencies("${NAME}.NO_BACKEND_SET" "${NAME}._no_backend_set_message")
# Set the default backend to the error message if no default is specified.
if("${arg_DEFAULT_BACKEND}" STREQUAL "")
set(arg_DEFAULT_BACKEND "${NAME}.NO_BACKEND_SET")
endif()
# Declare the backend variable for this facade.
set("${NAME}_BACKEND" "${arg_DEFAULT_BACKEND}" CACHE STRING
"Backend for ${NAME}")
# This target is never used; it simply tests that the specified backend
# actually exists in the build. The generator expression will fail to evaluate
# if the target is not defined.
add_custom_target(_pw_check_that_backend_for_${NAME}_is_defined
COMMAND
${CMAKE_COMMAND} -E echo "$<TARGET_PROPERTY:${${NAME}_BACKEND},TYPE>"
)
# Define the facade library, which is used by the backend to avoid circular
# dependencies.
add_library("${NAME}.facade" INTERFACE)
target_include_directories("${NAME}.facade" INTERFACE public)
pw_target_link_targets("${NAME}.facade" INTERFACE ${arg_PUBLIC_DEPS})
# Define the public-facing library for this facade, which depends on the
# header files in .facade target and exposes the dependency on the backend.
pw_add_module_library("${NAME}"
SOURCES
${arg_SOURCES}
HEADERS
${arg_HEADERS}
PUBLIC_DEPS
"${NAME}.facade"
"${${NAME}_BACKEND}"
)
endfunction(pw_add_facade)
# Sets which backend to use for the given facade.
function(pw_set_backend FACADE BACKEND)
set("${FACADE}_BACKEND" "${BACKEND}" CACHE STRING "Backend for ${FACADE}" FORCE)
endfunction(pw_set_backend)
# Zephyr specific wrapper for pw_set_backend, selects the default zephyr backend based on a Kconfig while
# still allowing the application to set the backend if they choose to
function(pw_set_zephyr_backend_ifdef COND FACADE BACKEND)
get_property(result CACHE "${FACADE}_BACKEND" PROPERTY TYPE)
if(${${COND}})
if("${result}" STREQUAL "")
pw_set_backend("${FACADE}" "${BACKEND}")
endif()
endif()
endfunction()
# Set up the default pw_build_DEFAULT_MODULE_CONFIG.
set("pw_build_DEFAULT_MODULE_CONFIG" pw_build.empty CACHE STRING
"Default implementation for all Pigweed module configurations.")
# Declares a module configuration variable for module libraries to depend on.
# Configs should be set to libraries which can be used to provide defines
# directly or though included header files.
#
# The configs can be selected either through the pw_set_module_config function
# to set the pw_build_DEFAULT_MODULE_CONFIG used by default for all Pigweed
# modules or by selecting a specific one for the given NAME'd configuration.
#
# Args:
#
# NAME: name to use for the target which can be depended on for the config.
function(pw_add_module_config NAME)
pw_parse_arguments_strict(pw_add_module_config 1 "" "" "")
# Declare the module configuration variable for this module.
set("${NAME}" "${pw_build_DEFAULT_MODULE_CONFIG}"
CACHE STRING "Module configuration for ${NAME}")
endfunction(pw_add_module_config)
# Sets which config library to use for the given module.
#
# This can be used to set a specific module configuration or the default
# module configuration used for all Pigweed modules:
#
# pw_set_module_config(pw_build_DEFAULT_MODULE_CONFIG my_config)
# pw_set_module_config(pw_foo_CONFIG my_foo_config)
function(pw_set_module_config NAME LIBRARY)
pw_parse_arguments_strict(pw_set_module_config 2 "" "" "")
# Update the module configuration variable.
set("${NAME}" "${LIBRARY}" CACHE STRING "Config for ${NAME}" FORCE)
endfunction(pw_set_module_config)
set(pw_unit_test_MAIN pw_unit_test.simple_printing_main CACHE STRING
"Implementation of a main function for ``pw_test`` unit test binaries.")
set(pw_unit_test_GOOGLETEST_BACKEND pw_unit_test.light CACHE STRING
"CMake target which implements GoogleTest, by default pw_unit_test.light \
is used. You could, for example, point this at pw_third_party.googletest \
if using upstream GoogleTest directly on your host for GoogleMock.")
# Declares a unit test. Creates two targets:
#
# * <TEST_NAME> - the test executable
# * <TEST_NAME>.run - builds and runs the test
#
# Args:
#
# NAME: name to use for the target
# SOURCES: source files for this test
# DEPS: libraries on which this test depends
# DEFINES: defines to set for the source files in this test
# GROUPS: groups to which to add this test; if none are specified, the test is
# added to the 'default' and 'all' groups
#
function(pw_add_test NAME)
pw_parse_arguments_strict(pw_add_test 1 "" "" "SOURCES;DEPS;DEFINES;GROUPS")
add_executable("${NAME}" EXCLUDE_FROM_ALL ${arg_SOURCES})
# TODO(ewout/hepler): Consider changing this to pw_target_link_targets once
# pw_auto_add_module_tests has been deprecated which relies on generator
# expressions.
target_link_libraries("${NAME}"
PRIVATE
pw_unit_test
${pw_unit_test_MAIN}
${arg_DEPS}
)
target_compile_definitions("${NAME}"
PRIVATE
${arg_DEFINES}
)
# Tests require at least one source file.
if(NOT arg_SOURCES)
target_sources("${NAME}" PRIVATE $<TARGET_PROPERTY:pw_build.empty,SOURCES>)
endif()
# Define a target for running the test. The target creates a stamp file to
# indicate successful test completion. This allows running tests in parallel
# with Ninja's full dependency resolution.
add_custom_command(
COMMAND
# TODO(hepler): This only runs local test binaries. Execute a test runner
# instead to support device test runs.
"$<TARGET_FILE:${NAME}>"
COMMAND
"${CMAKE_COMMAND}" -E touch "${NAME}.stamp"
DEPENDS
"${NAME}"
OUTPUT
"${NAME}.stamp"
)
add_custom_target("${NAME}.run" DEPENDS "${NAME}.stamp")
# Always add tests to the "all" group. If no groups are provided, add the
# test to the "default" group.
if(arg_GROUPS)
set(groups all ${arg_GROUPS})
else()
set(groups all default)
endif()
list(REMOVE_DUPLICATES groups)
pw_add_test_to_groups("${NAME}" ${groups})
endfunction(pw_add_test)
# Adds a test target to the specified test groups. Test groups can be built with
# the pw_tests_GROUP_NAME target or executed with the pw_run_tests_GROUP_NAME
# target.
function(pw_add_test_to_groups TEST_NAME)
foreach(group IN LISTS ARGN)
if(NOT TARGET "pw_tests.${group}")
add_custom_target("pw_tests.${group}")
add_custom_target("pw_run_tests.${group}")
endif()
add_dependencies("pw_tests.${group}" "${TEST_NAME}")
add_dependencies("pw_run_tests.${group}" "${TEST_NAME}.run")
endforeach()
endfunction(pw_add_test_to_groups)
# Adds compiler options to all targets built by CMake. Flags may be added any
# time after this function is defined. The effect is global; all targets added
# before or after a pw_add_global_compile_options call will be built with the
# flags, regardless of where the files are located.
#
# pw_add_global_compile_options takes one optional named argument:
#
# LANGUAGES: Which languages (ASM, C, CXX) to apply the options to. Flags
# apply to all languages by default.
#
# All other arguments are interpreted as compiler options.
function(pw_add_global_compile_options)
cmake_parse_arguments(PARSE_ARGV 0 args "" "" "LANGUAGES")
set(supported_build_languages ASM C CXX)
if(NOT args_LANGUAGES)
set(args_LANGUAGES ${supported_build_languages})
endif()
# Check the selected language.
foreach(lang IN LISTS args_LANGUAGES)
if(NOT "${lang}" IN_LIST supported_build_languages)
message(FATAL_ERROR "'${lang}' is not a supported language. "
"Supported languages: ${supported_build_languages}")
endif()
endforeach()
# Enumerate which flags variables to set.
foreach(lang IN LISTS args_LANGUAGES)
list(APPEND cmake_flags_variables "CMAKE_${lang}_FLAGS")
endforeach()
# Set each flag for each specified flags variable.
foreach(variable IN LISTS cmake_flags_variables)
foreach(flag IN LISTS args_UNPARSED_ARGUMENTS)
set(${variable} "${${variable}} ${flag}" CACHE INTERNAL "" FORCE)
endforeach()
endforeach()
endfunction(pw_add_global_compile_options)