if¶
Conditionally execute a group of commands.
Synopsis¶
if(<condition>)
<commands>
elseif(<condition>) # optional block, can be repeated
<commands>
else() # optional block
<commands>
endif()
Evaluates the condition
argument of the if
clause according to the
Condition syntax described below. If the result is true, then the
commands
in the if
block are executed.
Otherwise, optional elseif
blocks are processed in the same way.
Finally, if no condition
is true, commands
in the optional else
block are executed.
Per legacy, the else()
and endif()
commands admit
an optional <condition>
argument.
If used, it must be a verbatim
repeat of the argument of the opening
if
command.
Condition Syntax¶
The following syntax applies to the condition
argument of
the if
, elseif
and while()
clauses.
Compound conditions are evaluated in the following order of precedence:
Unary tests such as COMMAND, POLICY, TARGET, TEST, EXISTS, IS_READABLE, IS_WRITABLE, IS_EXECUTABLE, IS_DIRECTORY, IS_SYMLINK, IS_ABSOLUTE, and DEFINED.
Binary tests such as EQUAL, LESS, LESS_EQUAL, GREATER, GREATER_EQUAL, STREQUAL, STRLESS, STRLESS_EQUAL, STRGREATER, STRGREATER_EQUAL, VERSION_EQUAL, VERSION_LESS, VERSION_LESS_EQUAL, VERSION_GREATER, VERSION_GREATER_EQUAL, PATH_EQUAL, IN_LIST, IS_NEWER_THAN, and MATCHES.
Unary logical operator NOT.
Binary logical operators AND and OR, from left to right, without any short-circuit.
Basic Expressions¶
- if(<constant>)¶
True if the constant is
1
,ON
,YES
,TRUE
,Y
, or a non-zero number (including floating point numbers). False if the constant is0
,OFF
,NO
,FALSE
,N
,IGNORE
,NOTFOUND
, the empty string, or ends in the suffix-NOTFOUND
. Named boolean constants are case-insensitive. If the argument is not one of these specific constants, it is treated as a variable or string (see Variable Expansion further below) and one of the following two forms applies.
- if(<variable>)¶
True if given a variable that is defined to a value that is not a false constant. False otherwise, including if the variable is undefined. Note that macro arguments are not variables. Environment Variables also cannot be tested this way, e.g.
if(ENV{some_var})
will always evaluate to false.
Logic Operators¶
- if(NOT <condition>)¶
True if the condition is not true.
- if(<cond1> AND <cond2>)¶
True if both conditions would be considered true individually.
- if(<cond1> OR <cond2>)¶
True if either condition would be considered true individually.
- if((condition) AND (condition OR (condition)))¶
The conditions inside the parenthesis are evaluated first and then the remaining condition is evaluated as in the other examples. Where there are nested parenthesis the innermost are evaluated as part of evaluating the condition that contains them.
Existence Checks¶
- if(COMMAND <command-name>)¶
True if the given name is a command, macro or function that can be invoked.
- if(POLICY <policy-id>)¶
True if the given name is an existing policy (of the form
CMP<NNNN>
).
- if(TARGET <target-name>)¶
True if the given name is an existing logical target name created by a call to the
add_executable()
,add_library()
, oradd_custom_target()
command that has already been invoked (in any directory).
- if(TEST <test-name>)¶
Added in version 3.3.
True if the given name is an existing test name created by the
add_test()
command.
- if(DEFINED <name>|CACHE{<name>}|ENV{<name>})¶
True if a variable, cache variable or environment variable with given
<name>
is defined. The value of the variable does not matter. Note the following caveats:Macro arguments are not variables.
It is not possible to test directly whether a <name> is a non-cache variable. The expression
if(DEFINED someName)
will evaluate to true if either a cache or non-cache variablesomeName
exists. In comparison, the expressionif(DEFINED CACHE{someName})
will only evaluate to true if a cache variablesomeName
exists. Both expressions need to be tested if you need to know whether a non-cache variable exists:if(DEFINED someName AND NOT DEFINED CACHE{someName})
.
Added in version 3.14: Added support for
CACHE{<name>}
variables.
- if(<variable|string> IN_LIST <variable>)¶
Added in version 3.3.
True if the given element is contained in the named list variable.
File Operations¶
- if(EXISTS <path-to-file-or-directory>)¶
True if the named file or directory exists and is readable. Behavior is well-defined only for explicit full paths (a leading
~/
is not expanded as a home directory and is considered a relative path). Resolves symbolic links, i.e. if the named file or directory is a symbolic link, returns true if the target of the symbolic link exists.False if the given path is an empty string.
Note
Prefer
if(IS_READABLE)
to check file readability.if(EXISTS)
may be changed in the future to only check file existence.
- if(IS_READABLE <path-to-file-or-directory>)¶
Added in version 3.29.
True if the named file or directory is readable. Behavior is well-defined only for explicit full paths (a leading
~/
is not expanded as a home directory and is considered a relative path). Resolves symbolic links, i.e. if the named file or directory is a symbolic link, returns true if the target of the symbolic link is readable.False if the given path is an empty string.
- if(IS_WRITABLE <path-to-file-or-directory>)¶
Added in version 3.29.
True if the named file or directory is writable. Behavior is well-defined only for explicit full paths (a leading
~/
is not expanded as a home directory and is considered a relative path). Resolves symbolic links, i.e. if the named file or directory is a symbolic link, returns true if the target of the symbolic link is writable.False if the given path is an empty string.
- if(IS_EXECUTABLE <path-to-file-or-directory>)¶
Added in version 3.29.
True if the named file or directory is executable. Behavior is well-defined only for explicit full paths (a leading
~/
is not expanded as a home directory and is considered a relative path). Resolves symbolic links, i.e. if the named file or directory is a symbolic link, returns true if the target of the symbolic link is executable.False if the given path is an empty string.
- if(<file1> IS_NEWER_THAN <file2>)¶
True if
file1
is newer thanfile2
or if one of the two files doesn't exist. Behavior is well-defined only for full paths. If the file time stamps are exactly the same, anIS_NEWER_THAN
comparison returns true, so that any dependent build operations will occur in the event of a tie. This includes the case of passing the same file name for both file1 and file2.
- if(IS_DIRECTORY <path>)¶
True if
path
is a directory. Behavior is well-defined only for full paths.False if the given path is an empty string.
- if(IS_SYMLINK <path>)¶
True if the given path is a symbolic link. Behavior is well-defined only for full paths.
- if(IS_ABSOLUTE <path>)¶
True if the given path is an absolute path. Note the following special cases:
An empty
path
evaluates to false.On Windows hosts, any
path
that begins with a drive letter and colon (e.g.C:
), a forward slash or a backslash will evaluate to true. This means a path likeC:no\base\dir
will evaluate to true, even though the non-drive part of the path is relative.On non-Windows hosts, any
path
that begins with a tilde (~
) evaluates to true.
Comparisons¶
- if(<variable|string> MATCHES <regex>)¶
True if the given string or variable's value matches the given regular expression. See Regex Specification for regex format.
Added in version 3.9:
()
groups are captured inCMAKE_MATCH_<n>
variables.
- if(<variable|string> LESS <variable|string>)¶
True if the given string or variable's value parses as a real number (like a C
double
) and less than that on the right.
- if(<variable|string> GREATER <variable|string>)¶
True if the given string or variable's value parses as a real number (like a C
double
) and greater than that on the right.
- if(<variable|string> EQUAL <variable|string>)¶
True if the given string or variable's value parses as a real number (like a C
double
) and equal to that on the right.
- if(<variable|string> LESS_EQUAL <variable|string>)¶
Added in version 3.7.
True if the given string or variable's value parses as a real number (like a C
double
) and less than or equal to that on the right.
- if(<variable|string> GREATER_EQUAL <variable|string>)¶
Added in version 3.7.
True if the given string or variable's value parses as a real number (like a C
double
) and greater than or equal to that on the right.
- if(<variable|string> STRLESS <variable|string>)¶
True if the given string or variable's value is lexicographically less than the string or variable on the right.
- if(<variable|string> STRGREATER <variable|string>)¶
True if the given string or variable's value is lexicographically greater than the string or variable on the right.
- if(<variable|string> STREQUAL <variable|string>)¶
True if the given string or variable's value is lexicographically equal to the string or variable on the right.
- if(<variable|string> STRLESS_EQUAL <variable|string>)¶
Added in version 3.7.
True if the given string or variable's value is lexicographically less than or equal to the string or variable on the right.
- if(<variable|string> STRGREATER_EQUAL <variable|string>)¶
Added in version 3.7.
True if the given string or variable's value is lexicographically greater than or equal to the string or variable on the right.
Version Comparisons¶
- if(<variable|string> VERSION_LESS <variable|string>)¶
Component-wise integer version number comparison (version format is
major[.minor[.patch[.tweak]]]
, omitted components are treated as zero). Any non-integer version component or non-integer trailing part of a version component effectively truncates the string at that point.
- if(<variable|string> VERSION_GREATER <variable|string>)¶
Component-wise integer version number comparison (version format is
major[.minor[.patch[.tweak]]]
, omitted components are treated as zero). Any non-integer version component or non-integer trailing part of a version component effectively truncates the string at that point.
- if(<variable|string> VERSION_EQUAL <variable|string>)¶
Component-wise integer version number comparison (version format is
major[.minor[.patch[.tweak]]]
, omitted components are treated as zero). Any non-integer version component or non-integer trailing part of a version component effectively truncates the string at that point.
- if(<variable|string> VERSION_LESS_EQUAL <variable|string>)¶
Added in version 3.7.
Component-wise integer version number comparison (version format is
major[.minor[.patch[.tweak]]]
, omitted components are treated as zero). Any non-integer version component or non-integer trailing part of a version component effectively truncates the string at that point.
- if(<variable|string> VERSION_GREATER_EQUAL <variable|string>)¶
Added in version 3.7.
Component-wise integer version number comparison (version format is
major[.minor[.patch[.tweak]]]
, omitted components are treated as zero). Any non-integer version component or non-integer trailing part of a version component effectively truncates the string at that point.
Path Comparisons¶
- if(<variable|string> PATH_EQUAL <variable|string>)¶
Added in version 3.24.
Lexicographically compares two CMake paths component-by-component without accessing the filesystem. Only if every component of both paths match will the two paths compare equal. Multiple path separators are effectively collapsed into a single separator, but note that backslashes are not converted to forward slashes. No other path normalization is performed. Trailing slashes are preserved, thus
/a/b
and/a/b/
are not equal.Component-wise comparison is superior to string-based comparison due to the handling of multiple path separators. In the following example, the expression evaluates to true using
PATH_EQUAL
, but false withSTREQUAL
:# comparison is TRUE if ("/a//b/c" PATH_EQUAL "/a/b/c") ... endif() # comparison is FALSE if ("/a//b/c" STREQUAL "/a/b/c") ... endif()
See cmake_path(COMPARE) for more details.
Variable Expansion¶
The if command was written very early in CMake's history, predating
the ${}
variable evaluation syntax, and for convenience evaluates
variables named by its arguments as shown in the above signatures.
Note that normal variable evaluation with ${}
applies before the if
command even receives the arguments. Therefore code like
set(var1 OFF)
set(var2 "var1")
if(${var2})
appears to the if command as
if(var1)
and is evaluated according to the if(<variable>)
case documented
above. The result is OFF
which is false. However, if we remove the
${}
from the example then the command sees
if(var2)
which is true because var2
is defined to var1
which is not a false
constant.
Automatic evaluation applies in the other cases whenever the
above-documented condition syntax accepts <variable|string>
:
The left hand argument to MATCHES is first checked to see if it is a defined variable. If so, the variable's value is used, otherwise the original value is used.
If the left hand argument to MATCHES is missing it returns false without error
Both left and right hand arguments to LESS, GREATER, EQUAL, LESS_EQUAL, and GREATER_EQUAL, are independently tested to see if they are defined variables. If so, their defined values are used otherwise the original value is used.
Both left and right hand arguments to STRLESS, STRGREATER, STREQUAL, STRLESS_EQUAL, and STRGREATER_EQUAL are independently tested to see if they are defined variables. If so, their defined values are used otherwise the original value is used.
Both left and right hand arguments to VERSION_LESS, VERSION_GREATER, VERSION_EQUAL, VERSION_LESS_EQUAL, and VERSION_GREATER_EQUAL are independently tested to see if they are defined variables. If so, their defined values are used otherwise the original value is used.
The left hand argument to IN_LIST is tested to see if it is a defined variable. If so, the variable's value is used, otherwise the original value is used.
The right hand argument to NOT is tested to see if it is a boolean constant. If so, the value is used, otherwise it is assumed to be a variable and it is dereferenced.
The left and right hand arguments to AND and OR are independently tested to see if they are boolean constants. If so, they are used as such, otherwise they are assumed to be variables and are dereferenced.
Changed in version 3.1: To prevent ambiguity, potential variable or keyword names can be
specified in a Quoted Argument or a Bracket Argument.
A quoted or bracketed variable or keyword will be interpreted as a
string and not dereferenced or interpreted.
See policy CMP0054
.
There is no automatic evaluation for environment or cache
Variable References. Their values must be referenced as
$ENV{<name>}
or $CACHE{<name>}
wherever the above-documented
condition syntax accepts <variable|string>
.