Contents
Generator expressions are evaluated during build system generation to produce information specific to each build configuration.
Generator expressions are allowed in the context of many target properties, such as LINK_LIBRARIES, INCLUDE_DIRECTORIES, COMPILE_DEFINITIONS and others. They may also be used when using commands to populate those properties, such as target_link_libraries(), target_include_directories(), target_compile_definitions() and others.
This means that they enable conditional linking, conditional definitions used when compiling, and conditional include directories and more. The conditions may be based on the build configuration, target properties, platform information or any other queryable information.
Logical expressions are used to create conditional output. The basic expressions are the 0 and 1 expressions. Because other logical expressions evaluate to either 0 or 1, they can be composed to create conditional output:
$<$<CONFIG:Debug>:DEBUG_MODE>
expands to DEBUG_MODE when the Debug configuration is used, and otherwise expands to nothing.
Available logical expressions are:
1 if all ? are 1, else 0
The ? must always be either 0 or 1 in boolean expressions.
1 when the language used for compilation unit matches lang, otherwise 0. This expression used to specify compile options for source files of a particular language in a target. For example, to specify the use of the -fno-exceptions compile option (compiler id checks elided):
add_executable(myapp main.cpp foo.c bar.cpp)
target_compile_options(myapp
PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions>
)
This generator expression has limited use because it is not possible to use it with the Visual Studio generators. Portable buildsystems would not use this expression, and would create separate libraries for each source file language instead:
add_library(myapp_c foo.c)
add_library(myapp_cxx foo.c)
target_compile_options(myapp_cxx PUBLIC -fno-exceptions)
add_executable(myapp main.cpp)
target_link_libraries(myapp myapp_c myapp_cxx)
The Makefile and Ninja based generators can also use this expression to specify compile-language specific compile definitions and include directories:
add_executable(myapp main.cpp foo.c bar.cpp)
target_compile_definitions(myapp
PRIVATE $<$<COMPILE_LANGUAGE:CXX>:COMPILING_CXX>
)
target_include_directories(myapp
PRIVATE $<$<COMPILE_LANGUAGE:CXX>:/opt/foo/cxx_headers>
)
These expressions expand to some information. The information may be used directly, eg:
include_directories(/usr/include/$<CXX_COMPILER_ID>/)
expands to /usr/include/GNU/ or /usr/include/Clang/ etc, depending on the Id of the compiler.
These expressions may also may be combined with logical expressions:
$<$<VERSION_LESS:$<CXX_COMPILER_VERSION>,4.2.0>:OLD_COMPILER>
expands to OLD_COMPILER if the CMAKE_CXX_COMPILER_VERSION is less than 4.2.0.
Available informational expressions are:
Full path to the linker generated program database file (.pdb) where tgt is the name of a target.
See also the PDB_NAME and PDB_OUTPUT_DIRECTORY target properties and their configuration specific variants PDB_NAME_<CONFIG> and PDB_OUTPUT_DIRECTORY_<CONFIG>.
Value of the property prop on the target tgt.
Note that tgt is not added as a dependency of the target this expression is evaluated on.
These expressions generate output, in some cases depending on an input. These expressions may be combined with other expressions for information or logical comparison:
-I$<JOIN:$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>, -I>
generates a string of the entries in the INCLUDE_DIRECTORIES target property with each entry preceded by -I. Note that a more-complete use in this situation would require first checking if the INCLUDE_DIRECTORIES property is non-empty:
$<$<BOOL:${prop}>:-I$<JOIN:${prop}, -I>>
where ${prop} refers to a helper variable:
set(prop "$<TARGET_PROPERTY:INCLUDE_DIRECTORIES>")
Available output expressions are: