GNU make - 7. Conditional Parts of Makefiles

Go to the first, previous, next, last section, table of contents.

# 7. Conditional Parts of Makefiles

A conditional causes part of a makefile to be obeyed or ignored depending on the values of variables. Conditionals can compare the value of one variable to another, or the value of a variable to a constant string. Conditionals control what `make` actually "sees" in the makefile, so they cannot be used to control shell commands at the time of execution.

## 7.1 Example of a Conditional

The following example of a conditional tells `make` to use one set of libraries if the `CC` variable is ``gcc'`, and a different set of libraries otherwise. It works by controlling which of two command lines will be used as the command for a rule. The result is that ``CC=gcc'` as an argument to `make` changes not only which compiler is used but also which libraries are linked.

    libs_for_gcc = -lgnu
    normal_libs =

    foo: $(objects)
    ifeq ($(CC),gcc)
            $(CC) -o foo $(objects) $(libs_for_gcc)
    else
            $(CC) -o foo $(objects) $(normal_libs)
    endif

This conditional uses three directives: one `ifeq`, one `else` and one `endif`.

The `ifeq` directive begins the conditional, and specifies the condition. It contains two arguments, separated by a comma and surrounded by parentheses. Variable substitution is performed on both arguments and then they are compared. The lines of the makefile following the `ifeq` are obeyed if the two arguments match; otherwise they are ignored.

The `else` directive causes the following lines to be obeyed if the previous conditional failed. In the example above, this means that the second alternative linking command is used whenever the first alternative is not used. It is optional to have an `else` in a conditional.

The `endif` directive ends the conditional. Every conditional must end with an `endif`. Unconditional makefile text follows.

As this example illustrates, conditionals work at the textual level: the lines of the conditional are treated as part of the makefile, or ignored, according to the condition. This is why the larger syntactic units of the makefile, such as rules, may cross the beginning or the end of the conditional.

When the variable `CC` has the value ``gcc'`, the above example has this effect:

    foo: $(objects)
            $(CC) -o foo $(objects) $(libs_for_gcc)

When the variable `CC` has any other value, the effect is this:

    foo: $(objects)
            $(CC) -o foo $(objects) $(normal_libs)

Equivalent results can be obtained in another way by conditionalizing a variable assignment and then using the variable unconditionally:

    libs_for_gcc = -lgnu
    normal_libs =

    ifeq ($(CC),gcc)
      libs=$(libs_for_gcc)
    else
      libs=$(normal_libs)
    endif

    foo: $(objects)
            $(CC) -o foo $(objects) $(libs)

## 7.2 Syntax of Conditionals

The syntax of a simple conditional with no `else` is as follows:

    conditional-directive
    text-if-true
    endif

The text-if-true may be any lines of text, to be considered as part of the makefile if the condition is true. If the condition is false, no text is used instead.

The syntax of a complex conditional is as follows:

    conditional-directive
    text-if-true
    else
    text-if-false
    endif

If the condition is true, text-if-true is used; otherwise, text-if-false is used instead. The text-if-false can be any number of lines of text.

The syntax of the conditional-directive is the same whether the conditional is simple or complex. There are four different directives that test different conditions. Here is a table of them:

`ifeq (arg1, arg2)`
`ifeq 'arg1' 'arg2'`
`ifeq "arg1" "arg2"`
`ifeq "arg1" 'arg2'`
`ifeq 'arg1' "arg2"`
  Expand all variable references in arg1 and arg2 and compare them. If they are identical, the text-if-true is effective; otherwise, the text-if-false, if any, is effective. Often you want to test if a variable has a non-empty value. When the value results from complex expansions of variables and functions, expansions you would consider empty may actually contain whitespace characters and thus are not seen as empty. However, you can use the `strip` function (see section 8.2 Functions for String Substitution and Analysis) to avoid interpreting whitespace as a non-empty value. For example:

      ifeq ($(strip $(foo)),)
      text-if-empty
      endif

  will evaluate text-if-empty even if the expansion of `$(foo)` contains whitespace characters.
`ifneq (arg1, arg2)`
`ifneq 'arg1' 'arg2'`
`ifneq "arg1" "arg2"`
`ifneq "arg1" 'arg2'`
`ifneq 'arg1' "arg2"`
  Expand all variable references in arg1 and arg2 and compare them. If they are different, the text-if-true is effective; otherwise, the text-if-false, if any, is effective.
`ifdef variable-name`
  If the variable variable-name has a non-empty value, the text-if-true is effective; otherwise, the text-if-false, if any, is effective. Variables that have never been defined have an empty value. Note that `ifdef` only tests whether a variable has a value. It does not expand the variable to see if that value is nonempty. Consequently, tests using `ifdef` return true for all definitions except those like `foo =`. To test for an empty value, use `ifeq ($(foo),)`. For example,

      bar =
      foo = $(bar)
      ifdef foo
      frobozz = yes
      else
      frobozz = no
      endif

  sets ``frobozz'` to ``yes'`, while:

      foo =
      ifdef foo
      frobozz = yes
      else
      frobozz = no
      endif

  sets ``frobozz'` to ``no'`.
`ifndef variable-name`
  If the variable variable-name has an empty value, the text-if-true is effective; otherwise, the text-if-false, if any, is effective.

Extra spaces are allowed and ignored at the beginning of the conditional directive line, but a tab is not allowed. (If the line begins with a tab, it will be considered a command for a rule.) Aside from this, extra spaces or tabs may be inserted with no effect anywhere except within the directive name or within an argument. A comment starting with ``#'` may appear at the end of the line.

The other two directives that play a part in a conditional are `else` and `endif`. Each of these directives is written as one word, with no arguments. Extra spaces are allowed and ignored at the beginning of the line, and spaces or tabs at the end. A comment starting with ``#'` may appear at the end of the line.

Conditionals affect which lines of the makefile `make` uses. If the condition is true, `make` reads the lines of the text-if-true as part of the makefile; if the condition is false, `make` ignores those lines completely. It follows that syntactic units of the makefile, such as rules, may safely be split across the beginning or the end of the conditional.

`make` evaluates conditionals when it reads a makefile. Consequently, you cannot use automatic variables in the tests of conditionals because they are not defined until commands are run (see section 10.5.3 Automatic Variables).

To prevent intolerable confusion, it is not permitted to start a conditional in one makefile and end it in another. However, you may write an `include` directive within a conditional, provided you do not attempt to terminate the conditional inside the included file.

## 7.3 Conditionals that Test Flags

You can write a conditional that tests `make` command flags such as ``-t'` by using the variable `MAKEFLAGS` together with the `findstring` function (see section 8.2 Functions for String Substitution and Analysis). This is useful when `touch` is not enough to make a file appear up to date.

The `findstring` function determines whether one string appears as a substring of another. If you want to test for the ``-t'` flag, use ``t'` as the first string and the value of `MAKEFLAGS` as the other.

For example, here is how to arrange to use ``ranlib -t'` to finish marking an archive file up to date:

    archive.a: ...
    ifneq (,$(findstring t,$(MAKEFLAGS)))
            +touch archive.a
            +ranlib -t archive.a
    else
            ranlib archive.a
    endif

The ``+'` prefix marks those command lines as "recursive" so that they will be executed despite use of the ``-t'` flag. See section 5.6 Recursive Use of `make`.

Go to the first, previous, next, last section, table of contents.