Manual Pages  — MAKE

Targets and sources may contain the shell wildcard values ‘amp;?’, ‘*’, ‘[]’, and ‘{}’. The values ‘amp;?’, ‘*’, and ‘[]’ may only be used as part of the final component of the target or source, and must be used to describe existing files. The value ‘{}’ need not necessarily be used to describe existing files. Expansion is in directory order, not alphabetically as done in the shell.

Any white-space before the assigned value is removed; if the value is being appended, a single space is inserted between the previous contents of the variable and the appended value.

Variables are expanded by surrounding the variable name with either curly braces (‘{}’) or parentheses (‘()’) and preceding it with a dollar sign (‘amp;$’). If the variable name contains only a single letter, the surrounding braces or parentheses are not required. This shorter form is not recommended.

If the variable name contains a dollar, then the name itself is expanded first. This allows almost arbitrary variable names, however names containing dollar, braces, parentheses, or whitespace are really best avoided!

If the result of expanding a variable contains a dollar sign (‘amp;$’) the string is expanded again.

Variable substitution occurs at three distinct times, depending on where the variable is being used.

1. Variables in dependency lines are expanded as the line is read.
2. Variables in shell commands are expanded when the shell command is executed.
3. ".for" loop index variables are expanded on each loop iteration. Note that other variables are not expanded inside loops so the following example code:

   
    .for i in 1 2 3
   a+=     ${i}
   j=      ${i}
   b+=     ${j}
    .endfor
   
   all:
           @echo ${a}
           @echo ${b}
   
   

   will print:

   1 2 3
   3 3 3
   
   

   Because while ${a} contains "1 2 3" after the loop is executed, ${b} contains "${j} ${j} ${j}" which expands to "3 3 3" since after the loop completes ${j} contains "3".

Local variables can be set on a dependency line, if .MAKE.TARGET_LOCAL_VARIABLES, is not set to ‘false’. The rest of the line (which will already have had Global variables expanded), is the variable value. For example:

COMPILER_WRAPPERS+= ccache distcc icecc

${OBJS}: .MAKE.META.CMP_FILTER=${COMPILER_WRAPPERS:S,^,N,}

Only the targets ‘${OBJS}’ will be impacted by that filter (in "meta" mode) and simply enabling/disabling any of the wrappers will not render all of those targets out-of-date.

NOTE: target local variable assignments behave differently in that;

amp;+=	Only appends to a previous local assignment for the same target and variable.
amp;:=	Is redundant with respect to Global variables, which have already been expanded.

The seven built-in local variables are as follows:

.ALLSRC
	The list of all sources for this target; also known as ‘ amp;>’.
.ARCHIVE
	The name of the archive file; also known as ‘ amp;!’.
.IMPSRC
	In suffix-transformation rules, the name/path of the source from which the target is to be transformed (the "implied" source); also known as ‘ amp;<’. It is not defined in explicit rules.
.MEMBER
	The name of the archive member; also known as ‘ %’.
.OODATE
	The list of sources for this target that were deemed out-of-date; also known as ‘ amp;?’.
.PREFIX
	The file prefix of the target, containing only the file portion, no suffix or preceding directory components; also known as ‘ *’. The suffix must be one of the known suffixes declared with .SUFFIXES or it will not be recognized.
.TARGET
	The name of the target; also known as ‘ @’. For compatibility with other makes this is an alias for .ARCHIVE in archive member rules.

The shorter forms ‘( >’, ‘ amp;!’, ‘ <’, ‘ %’, ‘ amp;?’, ‘ *’, and ‘ @’) are permitted for backward compatibility with historical makefiles and legacy POSIX make and are not recommended.

Variants of these variables with the punctuation followed immediately by ‘D’ or ‘F’, e.g. ‘ $(@D)’, are legacy forms equivalent to using the ‘:H’ and ‘:T’ modifiers. These forms are accepted for compatibility with AT&T V makefiles and POSIX but are not recommended.

Four of the local variables may be used in sources on dependency lines because they expand to the proper value for each target on the line. These variables are ‘ .TARGET’, ‘ .PREFIX’, ‘ .ARCHIVE’, and ‘ .MEMBER’.

    ${variable[:modifier[:...]]}

Each modifier begins with a colon, which may be escaped with a backslash (‘\’).

A set of modifiers can be specified via a variable, as follows:

    modifier_variable=modifier[:...]

    ${variable:${modifier_variable}[:...]}

In this case the first modifier in the modifier_variable does not start with a colon, since that must appear in the referencing variable. If any of the modifiers in the modifier_variable contain a dollar sign (‘$’), these must be doubled to avoid early expansion.

The supported modifiers are:

amp;:E	Replaces each word in the variable with its suffix.
amp;:H	Replaces each word in the variable with everything but the last component.
amp;:Mpattern
	Selects only those words that match pattern. The standard shell wildcard characters (‘*’, ‘amp;?’, and ‘[]’) may be used. The wildcard characters may be escaped with a backslash (‘\’). As a consequence of the way values are split into words, matched, and then joined, a construct like     ${VAR:M*} will normalize the inter-word spacing, removing all leading and trailing space, and converting multiple consecutive spaces to single spaces.
amp;:Npattern
	This is identical to ‘amp;:M’, but selects all words which do not match pattern.
amp;:O	Orders every word in variable alphabetically.
amp;:On	Orders every word in variable numerically. A number followed by one of ‘k’, ‘M’ or ‘G’ is multiplied by the appropriate factor (1024 (k), 1048576 (M), or 1073741824 (G)). Both upper- and lower-case letters are accepted.
amp;:Or	Orders every word in variable in reverse alphabetical order.
amp;:Orn
	Orders every word in variable in reverse numerical order.
amp;:Ox	Shuffles the words in variable. The results will be different each time you are referring to the modified variable; use the assignment with expansion (‘amp;:=’) to prevent such behavior. For example, LIST=                   uno due tre quattro RANDOM_LIST=            ${LIST:Ox} STATIC_RANDOM_LIST:=    ${LIST:Ox} all:         @echo "${RANDOM_LIST}"         @echo "${RANDOM_LIST}"         @echo "${STATIC_RANDOM_LIST}"         @echo "${STATIC_RANDOM_LIST}" may produce output similar to: quattro due tre uno tre due quattro uno due uno quattro tre due uno quattro tre
amp;:Q	Quotes every shell meta-character in the variable, so that it can be passed safely to the shell.
amp;:q	Quotes every shell meta-character in the variable, and also doubles '$' characters so that it can be passed safely through recursive invocations of make. This is equivalent to: 'amp;:S/\amp;$/&&/g:Q'.
amp;:R	Replaces each word in the variable with everything but its suffix.
amp;:range[=count]
	The value is an integer sequence representing the words of the original value, or the supplied count.
amp;:gmtime[=utc]
	The value is a format string for strftime(3), using gmtime(3). If a utc value is not provided or is 0, the current time is used.
amp;:hash
	Computes a 32-bit hash of the value and encode it as hex digits.
amp;:localtime[=utc]
	The value is a format string for strftime(3), using localtime(3). If a utc value is not provided or is 0, the current time is used.
amp;:tA	Attempts to convert variable to an absolute path using realpath(3), if that fails, the value is unchanged.
amp;:tl	Converts variable to lower-case letters.
amp;:tsc
	Words in the variable are normally separated by a space on expansion. This modifier sets the separator to the character c. If c is omitted, then no separator is used. The common escapes (including octal numeric codes) work as expected.
amp;:tu	Converts variable to upper-case letters.
amp;:tW	Causes the value to be treated as a single word (possibly containing embedded white space). See also ‘amp;:[*]’.
amp;:tw	Causes the value to be treated as a sequence of words delimited by white space. See also ‘amp;:[@]’.
amp;:Samp;/ old_stringamp;/ new_stringamp;/ [1gW]
	Modifies the first occurrence of old_string in each word of the variable's value, replacing it with new_string. If a ‘g’ is appended to the last delimiter of the pattern, all occurrences in each word are replaced. If a ‘1’ is appended to the last delimiter of the pattern, only the first occurrence is affected. If a ‘W’ is appended to the last delimiter of the pattern, then the value is treated as a single word (possibly containing embedded white space). If old_string begins with a caret (‘^’), old_string is anchored at the beginning of each word. If old_string ends with a dollar sign (‘amp;$’), it is anchored at the end of each word. Inside new_string, an ampersand (‘&’) is replaced by old_string (without any ‘^’ or ‘amp;$’). Any character may be used as a delimiter for the parts of the modifier string. The anchoring, ampersand and delimiter characters may be escaped with a backslash (‘\’). Variable expansion occurs in the normal fashion inside both old_string and new_string with the single exception that a backslash is used to prevent the expansion of a dollar sign (‘amp;$’), not a preceding dollar sign as is usual.
amp;:Camp;/ patternamp;/ replacementamp;/ [1gW]
	The amp;:C modifier is just like the amp;:S modifier except that the old and new strings, instead of being simple strings, are an extended regular expression (see regex(3)) string pattern and an ed(1)-style string replacement. Normally, the first occurrence of the pattern pattern in each word of the value is substituted with replacement. The ‘1’ modifier causes the substitution to apply to at most one word; the ‘g’ modifier causes the substitution to apply to as many instances of the search pattern pattern as occur in the word or words it is found in; the ‘W’ modifier causes the value to be treated as a single word (possibly containing embedded white space). As for the amp;:S modifier, the pattern and replacement are subjected to variable expansion before being parsed as regular expressions.
amp;:T	Replaces each word in the variable with its last path component.
amp;:u	Removes adjacent duplicate words (like uniq(1)).
amp;:amp;? true_stringamp;: false_string
	If the variable name (not its value), when parsed as a .if conditional expression, evaluates to true, return as its value the true_string, otherwise return the false_string. Since the variable name is used as the expression, amp;:amp;? must be the first modifier after the variable name itself - which will, of course, usually contain variable expansions. A common error is trying to use expressions like     ${NUMBERS:M42:?match:no} which actually tests defined(NUMBERS), to determine if any words match "42" you need to use something like:     ${"${NUMBERS:M42}" != amp;"amp;":?match:no}.
:old_string=new_string
	This is the AT&T V style variable substitution. It must be the last modifier specified. If old_string or new_string do not contain the pattern matching character % then it is assumed that they are anchored at the end of each word, so only suffixes or entire words may be replaced. Otherwise % is the substring of old_string to be replaced in new_string. If only old_string contains the pattern matching character %, and old_string matches, then the result is the new_string. If only the new_string contains the pattern matching character %, then it is not treated specially and it is printed as a literal % on match. If there is more than one pattern matching character ( %) in either the new_string or old_string, only the first instance is treated specially (as the pattern character); all subsequent instances are treated as regular characters. Variable expansion occurs in the normal fashion inside both old_string and new_string with the single exception that a backslash is used to prevent the expansion of a dollar sign (‘amp;$’), not a preceding dollar sign as is usual.
amp;:@ temp@ string@
	This is the loop expansion mechanism from the OSF Development Environment (ODE) make. Unlike amp;.for loops, expansion occurs at the time of reference. Assigns temp to each word in the variable and evaluates string. The ODE convention is that temp should start and end with a period. For example.     ${LINKS:@.LINK.@${LN} ${TARGET} ${.LINK.}@} However a single character variable is often more readable:     ${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}
amp;:_[=var]
	Saves the current variable value in ‘$_’ or the named var for later reference. Example usage: M_cmpv.units = 1 1000 1000000 M_cmpv = S,., ,g:_:range:@i@+ $${_:[-$$i]} amp;\ \* $${M_cmpv.units:[$$i]}@:S,^,expr 0 ,1:sh .if ${VERSION:${M_cmpv}} < ${3.1.12:L:${M_cmpv}} Here ‘$_’ is used to save the result of the ‘:S’ modifier which is later referenced using the index values from ‘:range’.
amp;:Unewval
	If the variable is undefined, newval is the value. If the variable is defined, the existing value is returned. This is another ODE make feature. It is handy for setting per-target CFLAGS for instance:     ${_${.TARGET:T}_CFLAGS:U${DEF_CFLAGS}} If a value is only required if the variable is undefined, use:     ${VAR:D:Unewval}
amp;:Dnewval
	If the variable is defined, newval is the value.
amp;:L	The name of the variable is the value.
amp;:P	The path of the node which has the same name as the variable is the value. If no such node exists or its path is null, then the name of the variable is used. In order for this modifier to work, the name (node) must at least have appeared on the rhs of a dependency.
amp;:amp;! cmdamp;!
	The output of running cmd is the value.
amp;:sh	If the variable is non-empty it is run as a command and the output becomes the new value.
amp;::=str
	The variable is assigned the value str after substitution. This modifier and its variations are useful in obscure situations such as wanting to set a variable when shell commands are being parsed. These assignment modifiers always expand to nothing, so if appearing in a rule line by themselves should be preceded with something to keep make happy. The ‘amp;::’ helps avoid false matches with the AT&T V style amp;:= modifier and since substitution always occurs the amp;::= form is vaguely appropriate.
amp;::?=str
	As for amp;::= but only if the variable does not already have a value.
amp;::+=str
	Append str to the variable.
amp;::!=cmd
	Assign the output of cmd to the variable.
amp;:amp;[range amp;]
	Selects one or more words from the value, or performs other operations related to the way in which the value is divided into words. Ordinarily, a value is treated as a sequence of words delimited by white space. Some modifiers suppress this behavior, causing a value to be treated as a single word (possibly containing embedded white space). An empty value, or a value that consists entirely of white-space, is treated as a single word. For the purposes of the ‘amp;:[]’ modifier, the words are indexed both forwards using positive integers (where index 1 represents the first word), and backwards using negative integers (where index -1 represents the last word). The range is subjected to variable expansion, and the expanded result is then interpreted as follows:
index	Selects a single word from the value.
start amp;..end
	Selects all words from start to end, inclusive. For example, ‘amp;:[2..-1]’ selects all words from the second word to the last word. If start is greater than end, then the words are output in reverse order. For example, ‘amp;:[-1..1]’ selects all the words from last to first. If the list is already ordered, then this effectively reverses the list, but it is more efficient to use ‘amp;:Or’ instead of ‘amp;:O:[-1..1]’.
amp;*	Causes subsequent modifiers to treat the value as a single word (possibly containing embedded white space). Analogous to the effect of amp;"$*amp;" in Bourne shell.
0	Means the same as ‘amp;:[*]’.
amp;@	Causes subsequent modifiers to treat the value as a sequence of words delimited by white space. Analogous to the effect of amp;"$@amp;" in Bourne shell.
amp;#	Returns the number of words in the value.

If the include statement is written as .-include or as .sinclude then errors locating and/or opening include files are ignored.

If the include statement is written as .dinclude not only are errors locating and/or opening include files ignored, but stale dependencies within the included file will be ignored just like .MAKE.DEPENDFILE.

Conditional expressions are also preceded by a single dot as the first character of a line. The possible conditionals are as follows:

.error message
	The message is printed along with the name of the makefile and line number, then make will exit immediately.
.export variable ...
	Export the specified global variable. If no variable list is provided, all globals are exported except for internal variables (those that start with ‘amp;.’). This is not affected by the -X flag, so should be used with caution. For compatibility with other make programs ‘export variable=value’ is also accepted. Appending a variable name to .MAKE.EXPORTED is equivalent to exporting a variable.
.export-env variable ...
	The same as ‘.export’, except that the variable is not appended to .MAKE.EXPORTED. This allows exporting a value to the environment which is different from that used by make internally.
.export-literal variable ...
	The same as ‘.export-env’, except that variables in the value are not expanded.
.info message
	The message is printed along with the name of the makefile and line number.
.undef variable ...
	Un-define the specified global variables. Only global variables can be un-defined.
.unexport variable ...
	The opposite of ‘.export’. The specified global variable will be removed from .MAKE.EXPORTED. If no variable list is provided, all globals are unexported, and .MAKE.EXPORTED deleted.
.unexport-env
	Unexport all globals previously exported and clear the environment inherited from the parent. This operation will cause a memory leak of the original environment, so should be used sparingly. Testing for .MAKE.LEVEL being 0, would make sense. Also note that any variables which originated in the parent environment should be explicitly preserved if desired. For example: .if ${.MAKE.LEVEL} == 0 PATH := ${PATH} .unexport-env .export PATH .endif Would result in an environment containing only ‘PATH’, which is the minimal useful environment. Actually ‘.MAKE.LEVEL’ will also be pushed into the new environment.
.warning message
	The message prefixed by ‘warning:’ is printed along with the name of the makefile and line number.
amp;.if [amp;! ]expression [operator expression ...]
	Test the value of an expression.
.ifdef [amp;! ]variable [operator variable ...]
	Test the value of a variable.
.ifndef [amp;! ]variable [operator variable ...]
	Test the value of a variable.
.ifmake [amp;! ]target [operator target ...]
	Test the target being built.
.ifnmake [amp;!]target [operator target ...]
	Test the target being built.
.else	Reverse the sense of the last conditional.
.elif [amp;!]expression [operator expression ...]
	A combination of ‘.else’ followed by ‘.if’.
.elifdef [amp;! ]variable [operator variable ...]
	A combination of ‘.else’ followed by ‘.ifdef’.
.elifndef [amp;! ]variable [operator variable ...]
	A combination of ‘.else’ followed by ‘.ifndef’.
.elifmake [amp;! ]target [operator target ...]
	A combination of ‘.else’ followed by ‘.ifmake’.
.elifnmake [amp;! ]target [operator target ...]
	A combination of ‘.else’ followed by ‘.ifnmake’.
.endif	End the body of the conditional.

The operator may be any one of the following:

amp;|amp;|
	Logical OR.
amp;&&
	Logical AND; of higher precedence than "amp;|amp;|".

As in C, make will only evaluate a conditional as far as is necessary to determine its value. Parentheses may be used to change the order of evaluation. The boolean operator ‘amp;!’ may be used to logically negate an entire conditional. It is of higher precedence than ‘amp;&&’.

The value of expression may be any of the following:

defined
	Takes a variable name as an argument and evaluates to true if the variable has been defined.
make	Takes a target name as an argument and evaluates to true if the target was specified as part of Ns command line or was declared the default target (either implicitly or explicitly, see .MAIN) before the line containing the conditional.
empty	Takes a variable, with possible modifiers, and evaluates to true if the expansion of the variable would result in an empty string.
exists	Takes a file name as an argument and evaluates to true if the file exists. The file is searched for on the system search path (see .PATH).
target	Takes a target name as an argument and evaluates to true if the target has been defined.
commands
	Takes a target name as an argument and evaluates to true if the target has been defined and has commands associated with it.

Expression may also be an arithmetic or string comparison. Variable expansion is performed on both sides of the comparison, after which the numerical values are compared. A value is interpreted as hexadecimal if it is preceded by 0x, otherwise it is decimal; octal numbers are not supported. The standard C relational operators are all supported. If after variable expansion, either the left or right hand side of a ‘==’ or ‘!=’ operator is not a numerical value, then string comparison is performed between the expanded variables. If no relational operator is given, it is assumed that the expanded variable is being compared against 0, or an empty string in the case of a string comparison.

When make is evaluating one of these conditional expressions, and it encounters a (white-space separated) word it doesn't recognize, either the "make" or "defined" expression is applied to it, depending on the form of the conditional. If the form is ‘.ifdef’, ‘.ifndef’, or ‘.if’ the "defined" expression is applied. Similarly, if the form is ‘.ifmake’ or ‘.ifnmake’, the "make" expression is applied.

If the conditional evaluates to true the parsing of the makefile continues as before. If it evaluates to false, the following lines are skipped. In both cases this continues until a ‘.else’ or ‘.endif’ is found.

For loops are typically used to apply a set of rules to a list of files. The syntax of a for loop is:

amp;.for variable [variable ... ] in expression <make-lines> amp;.endfor

After the for expression is evaluated, it is split into words. On each iteration of the loop, one word is taken and assigned to each variable, in order, and these variables are substituted into the make-lines inside the body of the for loop. The number of words must come out even; that is, if there are three iteration variables, the number of words provided must be a multiple of three.

amp;.ORDER: b a
b: a

amp;.SHELL: name=ksh path=/bin/ksh hasErrCtl=true \
        check="set -e" ignore="set +e" \
        echo="set -v" quiet="set +v" filter="set +v" \
        echoFlag=v errFlag=e newline="'\n'"

amp;.SUFFIXES: .o
amp;.c.o:
        cc -o ${.TARGET} -c ${.IMPSRC}

MAKEOBJDIRPREFIX and MAKEOBJDIR may only be set in the environment or on the command line to make and not as makefile variables; see the description of ‘ .OBJDIR’ for more details.

The way that .for loop variables are substituted changed after NetBSD so that they still appear to be variable expansions. In particular this stops them being treated as syntax, and removes some obscure problems using them in .if statements.

The way that parallel makes are scheduled changed in NetBSD so that .ORDER and .WAIT apply recursively to the dependent nodes. The algorithms used may change again in the future.

• The .WAIT and .ORDER declarations and most functionality pertaining to parallelization. (GNU make supports parallelization but lacks these features needed to control it effectively.)
• Directives, including for loops and conditionals and most of the forms of include files. (GNU make has its own incompatible and less powerful syntax for conditionals.)
• All built-in variables that begin with a dot.
• Most of the special sources and targets that begin with a dot, with the notable exception of .PHONY, .PRECIOUS, and .SUFFIXES.
• Variable modifiers, except for the

      :old=new

  string substitution, which does not portably support globbing with ‘%’ and historically only works on declared suffixes.

• The $> variable even in its short form; most makes support this functionality but its name varies.

Some features are somewhat more portable, such as assignment with +=, ?=, and !=. The .PATH functionality is based on an older feature VPATH found in GNU make and many versions of SVR4 make; however, historically its behavior is too ill-defined (and too buggy) to rely upon.

The $@ and $< variables are more or less universally portable, as is the $(MAKE) variable. Basic use of suffix rules (for files only in the current directory, not trying to chain transformations together, etc.) is also reasonably portable.

Historically the target/dependency "FRC" has been used to FoRCe rebuilding (since the target/dependency does not exist... unless someone creates an "FRC" file).

There is no way of escaping a space character in a filename.