mirror of
https://fuchsia.googlesource.com/third_party/pigweed.googlesource.com/pigweed/pigweed
synced 2024-09-21 06:12:09 +00:00
6639c453aa
Previously, pw_tokenizer conditionally enabled the global handlers with macros. The default was that they were enabled, which meant handlers had to be defined, even if they weren't used. This change moves the two global handlers from the core pw_tokenizer library to separate facades. This allows projects to define only the global handlers they need. Change-Id: Ic8598d9e62921b706fa0b76032b2a14265669360
284 lines
9.2 KiB
CMake
284 lines
9.2 KiB
CMake
# 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)
|
|
|
|
# Create an empty, dummy source file for use by non-INTERFACE libraries, which
|
|
# require at least one source file.
|
|
set(_pw_empty_source_file "${CMAKE_BINARY_DIR}/pw_empty_source_file.cc")
|
|
file(WRITE "${_pw_empty_source_file}" "")
|
|
|
|
# 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 target_link_libraries arguments
|
|
# PRIVATE_DEPS: private target_link_libraries arguments
|
|
#
|
|
function(pw_auto_add_simple_module MODULE)
|
|
set(multi PUBLIC_DEPS PRIVATE_DEPS)
|
|
cmake_parse_arguments(PARSE_ARGV 1 arg "" "IMPLEMENTS_FACADE" "${multi}")
|
|
|
|
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$")
|
|
|
|
file(GLOB_RECURSE headers *.h)
|
|
|
|
if(arg_IMPLEMENTS_FACADE)
|
|
set(groups backends)
|
|
set(deps PUBLIC_DEPS "${arg_IMPLEMENTS_FACADE}.facade")
|
|
else()
|
|
set(groups modules "${MODULE}")
|
|
endif()
|
|
|
|
pw_add_module_library("${MODULE}"
|
|
PUBLIC_DEPS
|
|
${arg_PUBLIC_DEPS}
|
|
PRIVATE_DEPS
|
|
${arg_PRIVATE_DEPS}
|
|
SOURCES
|
|
${sources}
|
|
HEADERS
|
|
${headers}
|
|
${deps}
|
|
)
|
|
|
|
# Create a test for each source file ending in _test. Tests with mutliple .cc
|
|
# files or different dependencies than the module will not work correctly.
|
|
set(tests "${all_sources}")
|
|
list(FILTER tests INCLUDE REGEX "_test.cc$")
|
|
|
|
foreach(test IN LISTS tests)
|
|
get_filename_component(test_name "${test}" NAME_WE)
|
|
|
|
# Find a .c test corresponding with the test .cc file, if any.
|
|
list(FILTER c_test INCLUDE REGEX "^${test_name}.c$")
|
|
|
|
pw_add_test("${MODULE}.${test_name}"
|
|
SOURCES
|
|
"${test}"
|
|
${c_test}
|
|
DEPS
|
|
"${MODULE}"
|
|
${arg_PUBLIC_DEPS}
|
|
${arg_PRIVATE_DEPS}
|
|
GROUPS
|
|
"${groups}"
|
|
)
|
|
endforeach()
|
|
endfunction(pw_auto_add_simple_module)
|
|
|
|
# Creates a library in a module. The library has access to the public/ include
|
|
# directory.
|
|
#
|
|
# Args:
|
|
# SOURCES: source files for this library
|
|
# HEADERS: header files for this library
|
|
# PUBLIC_DEPS: public target_link_libraries arguments
|
|
# PRIVATE_DEPS: private target_link_libraries arguments
|
|
function(pw_add_module_library NAME)
|
|
set(list_args SOURCES HEADERS PUBLIC_DEPS PRIVATE_DEPS)
|
|
cmake_parse_arguments(PARSE_ARGV 1 arg "" "" "${list_args}")
|
|
|
|
# Check that the library's name is prefixed by the module name.
|
|
get_filename_component(module "${CMAKE_CURRENT_SOURCE_DIR}" NAME)
|
|
|
|
if(NOT "${NAME}" MATCHES "^${module}(\\.[^\\.]+)?(\\.facade|\\.backend)?$")
|
|
message(FATAL_ERROR
|
|
"Module libraries must match the module name or be in the form "
|
|
"'MODULE_NAME.LIBRARY_NAME'. The library '${NAME}' does not match."
|
|
)
|
|
endif()
|
|
|
|
add_library("${NAME}" EXCLUDE_FROM_ALL ${arg_HEADERS} ${arg_SOURCES})
|
|
target_include_directories("${NAME}" PUBLIC public/)
|
|
target_link_libraries("${NAME}"
|
|
PUBLIC
|
|
pw_build
|
|
${arg_PUBLIC_DEPS}
|
|
PRIVATE
|
|
${arg_PRIVATE_DEPS}
|
|
)
|
|
|
|
# Libraries require at least one source file.
|
|
if(NOT arg_SOURCES)
|
|
target_sources("${NAME}" PRIVATE "${_pw_empty_source_file}")
|
|
endif()
|
|
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.
|
|
function(pw_add_facade NAME)
|
|
pw_add_module_library("${NAME}.facade" ${ARGN})
|
|
|
|
# Use a library with an empty source instead of an INTERFACE library so that
|
|
# the library can have a private dependency on the backend.
|
|
add_library("${NAME}" OBJECT EXCLUDE_FROM_ALL "${_pw_empty_source_file}")
|
|
target_link_libraries("${NAME}"
|
|
PUBLIC
|
|
"${NAME}.facade"
|
|
"${NAME}.backend"
|
|
)
|
|
endfunction(pw_add_facade)
|
|
|
|
# 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
|
|
# 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)
|
|
cmake_parse_arguments(PARSE_ARGV 1 arg "" "" "SOURCES;DEPS;GROUPS")
|
|
|
|
add_executable("${NAME}" EXCLUDE_FROM_ALL ${arg_SOURCES})
|
|
target_link_libraries("${NAME}"
|
|
PRIVATE
|
|
pw_unit_test
|
|
pw_unit_test.main
|
|
${arg_DEPS}
|
|
)
|
|
|
|
# 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)
|
|
|
|
# Declare top-level targets for tests.
|
|
add_custom_target(pw_tests.default)
|
|
add_custom_target(pw_run_tests.default)
|
|
|
|
add_custom_target(pw_tests DEPENDS pw_tests.default)
|
|
add_custom_target(pw_run_tests DEPENDS pw_run_tests.default)
|
|
|
|
# Define the standard Pigweed compile options.
|
|
add_library(_pw_reduced_size_copts INTERFACE)
|
|
target_compile_options(_pw_reduced_size_copts
|
|
INTERFACE
|
|
"-fno-common"
|
|
"-fno-exceptions"
|
|
"-ffunction-sections"
|
|
"-fdata-sections"
|
|
$<$<COMPILE_LANGUAGE:CXX>:-fno-rtti>
|
|
)
|
|
|
|
add_library(_pw_strict_warnings_copts INTERFACE)
|
|
target_compile_options(_pw_strict_warnings_copts
|
|
INTERFACE
|
|
"-Wall"
|
|
"-Wextra"
|
|
# Make all warnings errors, except for the exemptions below.
|
|
"-Werror"
|
|
"-Wno-error=cpp" # preprocessor #warning statement
|
|
"-Wno-error=deprecated-declarations" # [[deprecated]] attribute
|
|
$<$<COMPILE_LANGUAGE:CXX>:-Wnon-virtual-dtor>
|
|
)
|
|
|
|
add_library(_pw_cpp17_copts INTERFACE)
|
|
target_compile_options(_pw_cpp17_copts
|
|
INTERFACE
|
|
$<$<COMPILE_LANGUAGE:CXX>:-std=c++17>
|
|
# Allow uses of the register keyword, which may appear in C headers.
|
|
$<$<COMPILE_LANGUAGE:CXX>:-Wno-register>
|
|
)
|
|
|
|
# Target that specifies the standard Pigweed build options.
|
|
add_library(pw_build INTERFACE)
|
|
target_compile_options(pw_build INTERFACE "-g")
|
|
target_link_libraries(pw_build
|
|
INTERFACE
|
|
_pw_reduced_size_copts
|
|
_pw_strict_warnings_copts
|
|
_pw_cpp17_copts
|
|
)
|
|
target_compile_options(pw_build
|
|
INTERFACE
|
|
# Force the compiler use colorized output. This is required for Ninja.
|
|
$<$<CXX_COMPILER_ID:Clang>:-fcolor-diagnostics>
|
|
$<$<CXX_COMPILER_ID:GNU>:-fdiagnostics-color=always>
|
|
)
|