Variables need not always be expanded verbatim. PMake defines several modifiers that may be applied to a variable's value before it is expanded. You apply a modifier by placing it after the variable name with a colon between the two, like so:
${VARIABLE:modifier}
Each modifier is a single character followed by something specific to the modifier itself. You may apply as many modifiers as you want - each one is applied to the result of the previous and is separated from the previous by another colon.
There are seven ways to modify a variable's expansion, most of which come from the C shell variable modification characters:
This is used to select only those words (a word is a series of characters that are
neither spaces nor tabs) that match the given pattern. The pattern is a wildcard
pattern like that used by the shell, where * means 0 or more characters of any sort; ? is any
single character; [abcd] matches any single character that is
either a, b, c or d (there may be any number of characters
between the brackets); [0-9] matches any single character
that is between 0 and 9 (i.e. any
digit. This form may be freely mixed with the other bracket form), and \ is used to escape any of the characters *,
?, [ or :,
leaving them as regular characters to match themselves in a word. For example, the
system makefile <makedepend.mk> uses $(CFLAGS:M-[ID]*) to extract all the -I
and
-D
flags that would be passed to the C compiler. This
allows it to properly locate include files and generate the correct dependencies.
This is identical to :M except it substitutes all words that do not match the given pattern.
Causes the first occurrence of search-string in the variable to be replaced by
replacement-string, unless the g
flag is given at the end,
in which case all occurrences of the string are replaced. The substitution is
performed on each word in the variable in turn. If search-string begins with a
^, the string must match starting at the beginning of the
word. If search-string ends with a $, the string must match to
the end of the word (these two may be combined to force an exact match). If a
backslash precedes these two characters, however, they lose their special meaning.
Variable expansion also occurs in the normal fashion inside both the search-string
and the replacement-string, except that a backslash is used to prevent the expansion of
a $, not another dollar sign, as is usual. Note that
search-string is just a string, not a pattern, so none of the usual
regularexpression/wildcard characters have any special meaning save ^ and $. In the replacement string, the
& character is replaced by the search-string unless it is
preceded by a backslash. You are allowed to use any character except colon or
exclamation point to separate the two strings. This so-called delimiter character may
be placed in either string by preceding it with a backslash.
Replaces each word in the variable expansion by its last component (its tail). For example, given:
OBJS = ../lib/a.o b /usr/lib/libm.a TAILS = $(OBJS:T)
the variable TAILS would expand to a.o b libm.a.
This is similar to :T, except that every word is replaced by everything but the tail (the head). Using the same definition of OBJS, the string $(OBJS:H) would expand to ../lib /usr/lib. Note that the final slash on the heads is removed and anything without a head is replaced by the empty string.
:E replaces each word by its suffix (extension). So $(OBJS:E) would give you .o .a.
This replaces each word by everything but the suffix (the root of the word). $(OBJS:R) expands to ../lib/a b /usr/lib/libm.
In addition, the System V style of substitution is also supported. This looks like:
$(VARIABLE:search-string=replacement)
It must be the last modifier in the chain. The search is anchored at the end of each word, so only suffixes or whole words may be replaced.