mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-06 17:18:32 +00:00
925 lines
55 KiB
Plaintext
925 lines
55 KiB
Plaintext
is a program designed to simplify the maintenance of other pro-
|
|
grams. Its input is a list of specifications as to the files
|
|
upon which programs and other files depend. If no option is
|
|
given, tries to open then in order to find the specifications.
|
|
If the file exists, it is read, see This manual page is intended
|
|
as a reference document only. For a more thorough description of
|
|
and makefiles, please refer to (from 1993). prepends the con-
|
|
tents of the environment variable to the command line arguments
|
|
before parsing them. The options are as follows: Try to be back-
|
|
wards compatible by executing a single shell per command and by
|
|
making the sources of a dependency line in sequence. Change to
|
|
before reading the makefiles or doing anything else. If multiple
|
|
options are specified, each is interpreted relative to the previ-
|
|
ous one: is equivalent to Define to be 1, in the global scope.
|
|
Turn on debugging, and specify which portions of are to print de-
|
|
bugging information. Unless the flags are preceded by they are
|
|
added to the environment variable and are passed on to any child
|
|
make processes. By default, debugging information is printed to
|
|
standard error, but this can be changed using the debugging flag.
|
|
The debugging output is always unbuffered; in addition, if debug-
|
|
ging is enabled but debugging output is not directed to standard
|
|
output, the standard output is line buffered. The available are:
|
|
Print all possible debugging information; equivalent to specify-
|
|
ing all of the debugging flags. Print debugging information
|
|
about archive searching and caching. Print debugging information
|
|
about the current working directory. Print debugging information
|
|
about conditional evaluation. Print debugging information about
|
|
directory searching and caching. Print debugging information
|
|
about failed commands and targets. Specify where debugging out-
|
|
put is written. This must be the last flag, because it consumes
|
|
the remainder of the argument. If the character immediately af-
|
|
ter the flag is the file is opened in append mode; otherwise the
|
|
file is overwritten. If the file name is or debugging output is
|
|
written to the standard output or standard error output respec-
|
|
tively (and the option has no effect). Otherwise, the output is
|
|
written to the named file. If the file name ends with the is re-
|
|
placed by the pid. Print debugging information about loop evalu-
|
|
ation. Print the input graph before making anything. Print the
|
|
input graph after making everything, or before exiting on error.
|
|
Print the input graph before exiting on error. Print debugging
|
|
information about hash table operations. Print debugging infor-
|
|
mation about running multiple shells. Turn on lint checks. This
|
|
throws errors for variable assignments that do not parse cor-
|
|
rectly, at the time of assignment, so the file and line number
|
|
are available. Print commands in Makefiles regardless of whether
|
|
or not they are prefixed by or other flags. Also known as behav-
|
|
ior. Print debugging information about mode decisions about tar-
|
|
gets. Print debugging information about making targets, includ-
|
|
ing modification dates. Don't delete the temporary command
|
|
scripts created when running commands. These temporary scripts
|
|
are created in the directory referred to by the environment vari-
|
|
able, or in if is unset or set to the empty string. The tempo-
|
|
rary scripts are created by and have names of the form This can
|
|
create many files in or so use with care. Print debugging infor-
|
|
mation about makefile parsing. Print debugging information about
|
|
suffix-transformation rules. Print debugging information about
|
|
target list maintenance. Force the option to print raw values of
|
|
variables, overriding the default behavior set via Print debug-
|
|
ging information about variable assignment and expansion. Run
|
|
shell commands with so the actual commands are printed as they
|
|
are executed. Let environment variables override global vari-
|
|
ables within makefiles. Specify a makefile to read instead of
|
|
the default or If is standard input is read. Multiple makefiles
|
|
may be specified, and are read in the order specified. Specify a
|
|
directory in which to search for makefiles and included make-
|
|
files. The system makefile directory (or directories, see the
|
|
option) is automatically included as part of this list. Ignore
|
|
non-zero exit of shell commands in the makefile. Equivalent to
|
|
specifying before each command line in the makefile. This option
|
|
should be specified by the user. When the option is in use in a
|
|
recursive build, this option is passed by a make to child makes
|
|
to allow all the make processes in the build to cooperate to
|
|
avoid overloading the system. Specify the maximum number of jobs
|
|
that may have running at any one time. If is a floating point
|
|
number, or ends with then the value is multiplied by the number
|
|
of CPUs reported online by The value of is saved in Turns compat-
|
|
ibility mode off, unless the option is also specified. When com-
|
|
patibility mode is off, all commands associated with a target are
|
|
executed in a single shell invocation as opposed to the tradi-
|
|
tional one shell invocation per line. This can break traditional
|
|
scripts which change directories on each command invocation and
|
|
then expect to start with a fresh environment on the next line.
|
|
It is more efficient to correct the scripts rather than turn
|
|
backwards compatibility on. A job token pool with tokens is used
|
|
to control the total number of jobs running. Each instance of
|
|
will wait for a token from the pool before running a new job.
|
|
Continue processing after errors are encountered, but only on
|
|
those targets that do not depend on the target whose creation
|
|
caused the error. Specify a directory in which to search for and
|
|
makefiles included via the include statement. The option can be
|
|
used multiple times to form a search path. This path overrides
|
|
the default system include path Furthermore, the system include
|
|
path is appended to the search path used for include statements
|
|
(see the option). The system include path can be referenced via
|
|
the read-only variable If a directory name in the argument (or
|
|
the environment variable) starts with the string searches for the
|
|
specified file or directory named in the remaining part of the
|
|
argument string. The search starts with the current directory
|
|
and then works upward towards the root of the file system. If
|
|
the search is successful, the resulting directory replaces the
|
|
specification in the argument. This feature allows to easily
|
|
search in the current source tree for customized files (e.g., by
|
|
using as an argument). Display the commands that would have been
|
|
executed, but do not actually execute them unless the target de-
|
|
pends on the special source (see below) or the command is pre-
|
|
fixed with Display the commands that would have been executed,
|
|
but do not actually execute any of them; useful for debugging
|
|
top-level makefiles without descending into subdirectories. Do
|
|
not execute any commands, instead exit 0 if the specified targets
|
|
are up to date, and 1 otherwise. Do not use the built-in rules
|
|
specified in the system makefile. Stop processing if an error is
|
|
encountered. This is the default behavior and the opposite of Do
|
|
not echo any commands as they are executed. Equivalent to speci-
|
|
fying before each command line in the makefile. When used with
|
|
the flag, append a trace record to for each job started and com-
|
|
pleted. Rather than re-building a target as specified in the
|
|
makefile, create it or update its modification time to make it
|
|
appear up-to-date. Print the value of Do not build any targets.
|
|
Multiple instances of this option may be specified; the variables
|
|
are printed one per line, with a blank line for each null or un-
|
|
defined variable. The value printed is extracted from the global
|
|
scope after all makefiles have been read. By default, the raw
|
|
variable contents (which may include additional unexpanded vari-
|
|
able references) are shown. If contains a it is not interpreted
|
|
as a variable name but rather as an expression. Its value is ex-
|
|
panded before printing. The value is also expanded before print-
|
|
ing if is set to true and the option has not been used to over-
|
|
ride it. Note that loop-local and target-local variables, as
|
|
well as values taken temporarily by global variables during make-
|
|
file processing, are not accessible via this option. The debug
|
|
mode can be used to see these at the cost of generating substan-
|
|
tial extraneous output. Like but all printed variables are al-
|
|
ways expanded to their complete value. The last occurrence of or
|
|
decides whether all variables are expanded or not. Treat any
|
|
warnings during makefile parsing as errors. Print entering and
|
|
leaving directory messages, pre and post processing. Don't ex-
|
|
port variables passed on the command line to the environment in-
|
|
dividually. Variables passed on the command line are still ex-
|
|
ported via the environment variable. This option may be useful
|
|
on systems which have a small limit on the size of command argu-
|
|
ments. Set the value of the variable to Normally, all values
|
|
passed on the command line are also exported to sub-makes in the
|
|
environment. The flag disables this behavior. Variable assign-
|
|
ments should follow options for POSIX compatibility but no order-
|
|
ing is enforced. There are several different types of lines in a
|
|
makefile: dependency specifications, shell commands, variable as-
|
|
signments, include statements, conditional directives, for loops,
|
|
other directives, and comments. Lines may be continued from one
|
|
line to the next by ending them with a backslash The trailing
|
|
newline character and initial whitespace on the following line
|
|
are compressed into a single space. Dependency lines consist of
|
|
one or more targets, an operator, and zero or more sources. This
|
|
creates a relationship where the targets on the sources and are
|
|
customarily created from them. A target is considered out of
|
|
date if it does not exist, or if its modification time is less
|
|
than that of any of its sources. An out-of-date target is re-
|
|
created, but not until all sources have been examined and them-
|
|
selves re-created as needed. Three operators may be used: Many
|
|
dependency lines may name this target but only one may have at-
|
|
tached shell commands. All sources named in all dependency lines
|
|
are considered together, and if needed the attached shell com-
|
|
mands are run to create or re-create the target. If is inter-
|
|
rupted, the target is removed. The same, but the target is al-
|
|
ways re-created whether or not it is out of date. Any dependency
|
|
line may have attached shell commands, but each one is handled
|
|
independently: its sources are considered and the attached shell
|
|
commands are run if the target is out of date with respect to
|
|
(only) those sources. Thus, different groups of the attached
|
|
shell commands may be run depending on the circumstances. Fur-
|
|
thermore, unlike for dependency lines with no sources, the at-
|
|
tached shell commands are always run. Also unlike the target is
|
|
not removed if is interrupted. All dependency lines mentioning a
|
|
particular target must use the same operator. Targets and
|
|
sources may contain the shell wildcard values and The values and
|
|
may only be used as part of the final component of the target or
|
|
source, and only match existing files. The value need not neces-
|
|
sarily be used to describe existing files. Expansion is in di-
|
|
rectory order, not alphabetically as done in the shell. Each
|
|
target may have associated with it one or more lines of shell
|
|
commands, normally used to create the target. Each of the lines
|
|
in this script be preceded by a tab. (For historical reasons,
|
|
spaces are not accepted.) While targets can occur in many depen-
|
|
dency lines if desired, by default only one of these rules may be
|
|
followed by a creation script. If the operator is used, however,
|
|
all rules may include scripts, and the respective scripts are ex-
|
|
ecuted in the order found. Each line is treated as a separate
|
|
shell command, unless the end of line is escaped with a backslash
|
|
in which case that line and the next are combined. If the first
|
|
characters of the command are any combination of or the command
|
|
is treated specially. causes the command not to be echoed before
|
|
it is executed. causes the command to be executed even when is
|
|
given. This is similar to the effect of the special source, ex-
|
|
cept that the effect can be limited to a single line of a script.
|
|
in compatibility mode causes any non-zero exit status of the com-
|
|
mand line to be ignored. When is run in jobs mode with the en-
|
|
tire script for the target is fed to a single instance of the
|
|
shell. In compatibility (non-jobs) mode, each command is run in
|
|
a separate process. If the command contains any shell meta char-
|
|
acters it is passed to the shell; otherwise attempts direct exe-
|
|
cution. If a line starts with and the shell has ErrCtl enabled,
|
|
failure of the command line is ignored as in compatibility mode.
|
|
Otherwise affects the entire job; the script stops at the first
|
|
command line that fails, but the target is not deemed to have
|
|
failed. Makefiles should be written so that the mode of opera-
|
|
tion does not change their behavior. For example, any command
|
|
which uses or without the intention of changing the directory for
|
|
subsequent commands should be put in parentheses so it executes
|
|
in a subshell. To force the use of a single shell, escape the
|
|
line breaks so as to make the whole script one command. For ex-
|
|
ample: avoid-chdir-side-effects: @echo "Building $@ in
|
|
$$(pwd)" @(cd ${.CURDIR} && ${MAKE} $@) @echo
|
|
"Back in $$(pwd)"
|
|
|
|
ensure-one-shell-regardless-of-mode: @echo "Building $@
|
|
in $$(pwd)"; \ (cd ${.CURDIR} && ${MAKE} $@); \
|
|
echo "Back in $$(pwd)" Since changes the current working
|
|
directory to before executing any targets, each child process
|
|
starts with that as its current working directory. Variables in
|
|
make behave much like macros in the C preprocessor. Variable as-
|
|
signments have the form where: is a single-word variable name,
|
|
consisting, by tradition, of all upper-case letters, is one of
|
|
the variable assignment operators described below, and is inter-
|
|
preted according to the variable assignment operator. Whitespace
|
|
around and is discarded. The five operators that assign values
|
|
to variables are: Assign the value to the variable. Any previous
|
|
value is overwritten. Append the value to the current value of
|
|
the variable, separating them by a single space. Assign the
|
|
value to the variable if it is not already defined. Expand the
|
|
value, then assign it to the variable. References to undefined
|
|
variables are expanded. This can cause problems when variable
|
|
modifiers are used. Expand the value and pass it to the shell
|
|
for execution, then assign the output from the child's standard
|
|
output to the variable. Any newlines in the result are replaced
|
|
with spaces. In most contexts where variables are expanded, ex-
|
|
pands to a single dollar sign. In other contexts (most variable
|
|
modifiers, string literals in conditions), expands to a single
|
|
dollar sign. References to variables have the form or If the
|
|
variable name consists of only a single character and the expres-
|
|
sion contains no modifiers, the surrounding curly braces or
|
|
parentheses are not required. This shorter form is not recom-
|
|
mended. If the variable name contains a dollar, the name itself
|
|
is expanded first. This allows almost arbitrary variable names,
|
|
however names containing dollar, braces, parentheses or white-
|
|
space are really best avoided. If the result of expanding a
|
|
nested variable expression contains a dollar sign the result is
|
|
subject to further expansion. Variable substitution occurs at
|
|
four distinct times, depending on where the variable is being
|
|
used. Variables in dependency lines are expanded as the line is
|
|
read. Variables in conditionals are expanded individually, but
|
|
only as far as necessary to determine the result of the condi-
|
|
tional. Variables in shell commands are expanded when the shell
|
|
command is executed. loop index variables are expanded on each
|
|
loop iteration. Note that other variables are not expanded when
|
|
composing the body of a loop, so the following example code: .for
|
|
i in 1 2 3 a+= ${i} j= ${i} b+= ${j} .endfor
|
|
|
|
all: @echo ${a} @echo ${b} prints: 1 2 3 3 3 3
|
|
After the loop is executed: contains which expands to contains
|
|
which expands to contains which expands to and further to The
|
|
four different classes of variables (in order of increasing
|
|
precedence) are: Variables defined as part of environment. Vari-
|
|
ables defined in the makefile or in included makefiles. Vari-
|
|
ables defined as part of the command line. Variables that are
|
|
defined specific to a certain target. Local variables can be set
|
|
on a dependency line, unless is set to The rest of the line
|
|
(which already has 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 are impacted by that filter (in mode) and simply en-
|
|
abling/disabling any of the compiler wrappers does not render all
|
|
of those targets out-of-date. target-local variable assignments
|
|
behave differently in that; Only appends to a previous local as-
|
|
signment for the same target and variable. Is redundant with re-
|
|
spect to global variables, which have already been expanded. The
|
|
seven built-in local variables are: The list of all sources for
|
|
this target; also known as The name of the archive file; also
|
|
known as In suffix-transformation rules, the name/path of the
|
|
source from which the target is to be transformed (the source);
|
|
also known as It is not defined in explicit rules. The name of
|
|
the archive member; also known as The list of sources for this
|
|
target that were deemed out-of-date; also known as The name of
|
|
the target with suffix (if declared in removed; also known as The
|
|
name of the target; also known as For compatibility with other
|
|
makes this is an alias for in archive member rules. The shorter
|
|
forms and are permitted for backward compatibility with histori-
|
|
cal makefiles and legacy POSIX make and are not recommended.
|
|
Variants of these variables with the punctuation followed immedi-
|
|
ately by or e.g. are legacy forms equivalent to using the and
|
|
modifiers. These forms are accepted for compatibility with make-
|
|
files and POSIX but are not recommended. Four of the local vari-
|
|
ables may be used in sources on dependency lines because they ex-
|
|
pand to the proper value for each target on the line. These
|
|
variables are and In addition, sets or knows about the following
|
|
variables: The list of all targets encountered in the makefiles.
|
|
If evaluated during makefile parsing, lists only those targets
|
|
encountered thus far. A path to the directory where was exe-
|
|
cuted. Refer to the description of for more details. Is used in
|
|
error handling, see Is used in error handling, see Is used in er-
|
|
ror handling, see Is used in error handling in mode, see Is used
|
|
in error handling, see The directory of the file this makefile
|
|
was included from. The filename of the file this makefile was
|
|
included from. The machine hardware name, see The machine
|
|
processor architecture name, see The name that was executed with
|
|
The same as for compatibility. The preferred variable to use is
|
|
the environment variable because it is more compatible with other
|
|
make variants and cannot be confused with the special target with
|
|
the same name. Names the makefile (default from which generated
|
|
dependencies are read. If set to do not print error information
|
|
at the end. A boolean that controls the default behavior of the
|
|
option. If true, variable values printed with are fully ex-
|
|
panded; if false, the raw variable contents (which may include
|
|
additional unexpanded variable references) are shown. The list
|
|
of variables exported by The top-level makefile that is currently
|
|
read, as given in the command line. The environment variable may
|
|
contain anything that may be specified on command line. Anything
|
|
specified on command line is appended to the variable, which is
|
|
then added to the environment for all programs that executes.
|
|
The numeric group ID of the user running It is read-only. If is
|
|
run with the output for each target is prefixed with a token the
|
|
first part of which can be controlled via If is empty, no token
|
|
is printed. For example, setting to would produce tokens like
|
|
making it easier to track the degree of parallelism being
|
|
achieved. The argument to the option. A read-only boolean that
|
|
indicates whether the option supports use of The recursion depth
|
|
of The top-level instance of has level 0, and each child make has
|
|
its parent level plus 1. This allows tests like: to protect
|
|
things which should only be evaluated in the top-level instance
|
|
of The name of the environment variable that stores the level of
|
|
nested calls to The ordered list of makefile names (default that
|
|
looks for. The list of makefiles read by which is useful for
|
|
tracking dependencies. Each makefile is recorded only once, re-
|
|
gardless of the number of times read. In mode, provides a list
|
|
of prefixes which match the directories controlled by If a file
|
|
that was generated outside of but within said bailiwick is miss-
|
|
ing, the current target is considered out-of-date. In mode, it
|
|
can (very rarely!) be useful to filter command lines before com-
|
|
parison. This variable can be set to a set of modifiers that are
|
|
applied to each line of the old and new command that differ, if
|
|
the filtered commands still differ, the target is considered out-
|
|
of-date. In mode, this variable contains a list of all the meta
|
|
files updated. If not empty, it can be used to trigger process-
|
|
ing of In mode, this variable contains a list of all the meta
|
|
files used (updated or not). This list can be used to process
|
|
the meta files to extract dependency information. Provides a
|
|
list of variable modifiers to apply to each pathname. Ignore if
|
|
the expansion is an empty string. Provides a list of path pre-
|
|
fixes that should be ignored; because the contents are expected
|
|
to change over time. The default list includes: Provides a list
|
|
of patterns to match against pathnames. Ignore any that match.
|
|
Defines the message printed for each meta file updated in mode.
|
|
The default value is: Processed after reading all makefiles. Af-
|
|
fects the mode that runs in. It can contain these keywords: Like
|
|
puts into mode. Puts into mode, where meta files are created for
|
|
each target to capture the command run, the output generated, and
|
|
if is available, the system calls which are of interest to The
|
|
captured output can be useful when diagnosing errors. By de-
|
|
fault, does not create files in This can be overridden by setting
|
|
to a value which represents true. If is true, a missing file
|
|
makes the target out-of-date. If is true, missing filemon data
|
|
makes the target out-of-date. Do not use For debugging, it can
|
|
be useful to include the environment in the file. If in mode,
|
|
print a clue about the target being built. This is useful if the
|
|
build is otherwise running silently. The message printed is the
|
|
expanded value of Some makefiles have commands which are simply
|
|
not stable. This keyword causes them to be ignored for determin-
|
|
ing whether a target is out of date in mode. See also If is
|
|
true, when a .meta file is created, mark the target In both com-
|
|
pat and parallel mode, do not make the targets in the usual or-
|
|
der, but instead randomize their order. This mode can be used to
|
|
detect undeclared dependencies between files. Used to create
|
|
files in a separate directory, see Used to force a separate di-
|
|
rectory for the created files, even if that directory is not
|
|
writable, see Used to create files in a separate directory, see
|
|
The name of the operating system, see It is read-only. This
|
|
variable is used to record the names of variables assigned to on
|
|
the command line, so that they may be exported as part of This
|
|
behavior can be disabled by assigning an empty value to within a
|
|
makefile. Extra variables can be exported from a makefile by ap-
|
|
pending their names to is re-exported whenever is modified. If
|
|
was built with support, this is set to the path of the device
|
|
node. This allows makefiles to test for this support. The
|
|
process ID of It is read-only. The parent process ID of It is
|
|
read-only. When stops due to an error, it sets to the name of
|
|
the target that failed, to the exit status of the failed target,
|
|
to the commands of the failed target, and in mode, it also sets
|
|
to the and to the path of the meta file (if any) describing the
|
|
failed target. It then prints its name and the value of as well
|
|
as the value of any variables named in If true, are preserved
|
|
when doing assignments. The default is false, for backwards com-
|
|
patibility. Set to true for compatability with other makes. If
|
|
set to false, becomes per normal evaluation rules. If set to ap-
|
|
parent variable assignments in dependency lines are treated as
|
|
normal sources. The numeric ID of the user running It is read-
|
|
only. This variable is simply assigned a newline character as
|
|
its value. It is read-only. This allows expansions using the
|
|
modifier to put a newline between iterations of the loop rather
|
|
than a space. For example, in case of an error, prints the vari-
|
|
able names and their values using: A path to the directory where
|
|
the targets are built. Its value is determined by trying to to
|
|
the following directories in order and using the first match:
|
|
(Only if is set in the environment or on the command line.)
|
|
(Only if is set in the environment or on the command line.)
|
|
Variable expansion is performed on the value before it is used,
|
|
so expressions such as may be used. This is especially useful
|
|
with may be modified in the makefile via the special target In
|
|
all cases, changes to the specified directory if it exists, and
|
|
sets and to that directory before executing any targets. Except
|
|
in the case of an explicit target, checks that the specified di-
|
|
rectory is writable and ignores it if not. This check can be
|
|
skipped by setting the environment variable to The directory name
|
|
of the current makefile being parsed. The basename of the cur-
|
|
rent makefile being parsed. This variable and are both set only
|
|
while the makefiles are being parsed. To retain their current
|
|
values, assign them to a variable using assignment with expansion
|
|
The space-separated list of directories that searches for files.
|
|
To update this search list, use the special target rather than
|
|
modifying the variable directly. Is set in POSIX mode, see the
|
|
special target. Alternate path to the current directory. nor-
|
|
mally sets to the canonical path given by However, if the envi-
|
|
ronment variable is set and gives a path to the current direc-
|
|
tory, sets to the value of instead. This behavior is disabled if
|
|
is set or contains a variable transform. is set to the value of
|
|
for all programs which executes. The pathname of the shell used
|
|
to run target scripts. It is read-only. The list of known suf-
|
|
fixes. It is read-only. The space-separated list of directories
|
|
that searches for makefiles, referred to as the system include
|
|
path. To update this search list, use the special target rather
|
|
than modifying the variable which is read-only. The list of tar-
|
|
gets explicitly specified on the command line, if any. The
|
|
colon-separated list of directories that searches for files.
|
|
This variable is supported for compatibility with old make pro-
|
|
grams only, use instead. The general format of a variable expan-
|
|
sion is: Each modifier begins with a colon. To escape a colon,
|
|
precede it with a backslash A list of indirect modifiers can be
|
|
specified via a variable, as follows:
|
|
|
|
In this case, the first modifier in the does not start with a
|
|
colon, since that colon already occurs in the referencing vari-
|
|
able. If any of the modifiers in the contains a dollar sign
|
|
these must be doubled to avoid early expansion. Some modifiers
|
|
interpret the expression value as a single string, others treat
|
|
the expression value as a whitespace-separated list of words.
|
|
When splitting a string into words, whitespace can be escaped us-
|
|
ing double quotes, single quotes and backslashes, like in the
|
|
shell. The quotes and backslashes are retained in the words.
|
|
The supported modifiers are: Replaces each word with its suffix.
|
|
Replaces each word with its dirname. Selects only those words
|
|
that match The standard shell wildcard characters 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, the construct removes all leading and trailing
|
|
whitespace and normalizes the inter-word spacing to a single
|
|
space. This is the opposite of selecting all words which do
|
|
match Orders the words lexicographically. Orders the words nu-
|
|
merically. A number followed by one of or is multiplied by the
|
|
appropriate factor, which is 1024 for 1048576 for or 1073741824
|
|
for Both upper- and lower-case letters are accepted. Orders the
|
|
words in reverse lexicographical order. Orders the words in re-
|
|
verse numerical order. Shuffles the words. The results are dif-
|
|
ferent each time you are referring to the modified variable; use
|
|
the assignment with expansion to prevent such behavior. For ex-
|
|
ample, LIST= uno due tre quattro RAN-
|
|
DOM_LIST= ${LIST:Ox} STATIC_RAN-
|
|
DOM_LIST:= ${LIST:Ox}
|
|
|
|
all: @echo "${RANDOM_LIST}" @echo "${RAN-
|
|
DOM_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 quat-
|
|
tro tre Quotes every shell meta-character in the value, so that
|
|
it can be passed safely to the shell. Quotes every shell meta-
|
|
character in the value, and also doubles characters so that it
|
|
can be passed safely through recursive invocations of This is
|
|
equivalent to Replaces each word with everything but its suffix.
|
|
The value is an integer sequence representing the words of the
|
|
original value, or the supplied The value is interpreted as a
|
|
format string for using producing the formatted timestamp. Note:
|
|
the format should only be used with If a value is not provided or
|
|
is 0, the current time is used. Computes a 32-bit hash of the
|
|
value and encodes it as 8 hex digits. The value is interpreted
|
|
as a format string for using producing the formatted timestamp.
|
|
If a value is not provided or is 0, the current time is used.
|
|
Call with each word as pathname; use as the new value. If fails;
|
|
use or current time. If is set to then failure will cause an er-
|
|
ror. Attempts to convert the value to an absolute path using If
|
|
that fails, the value is unchanged. Converts the value to lower-
|
|
case letters. When joining the words after a modifier that
|
|
treats the value as words, the words are normally separated by a
|
|
space. This modifier changes the separator to the character If
|
|
is omitted, no separator is used. The common escapes (including
|
|
octal numeric codes) work as expected. Converts the value to up-
|
|
per-case letters. Causes subsequent modifiers to treat the value
|
|
as a single word (possibly containing embedded whitespace). See
|
|
also Causes the value to be treated as a list of words. See also
|
|
Modifies the first occurrence of in each word of the value, re-
|
|
placing it with If a is appended to the last delimiter of the
|
|
pattern, all occurrences in each word are replaced. If a is ap-
|
|
pended to the last delimiter of the pattern, only the first oc-
|
|
currence is affected. If a is appended to the last delimiter of
|
|
the pattern, the value is treated as a single word. If begins
|
|
with a caret is anchored at the beginning of each word. If ends
|
|
with a dollar sign it is anchored at the end of each word. In-
|
|
side an ampersand is replaced by (without the anchoring or Any
|
|
character may be used as the delimiter for the parts of the modi-
|
|
fier string. The anchoring, ampersand and delimiter characters
|
|
can be escaped with a backslash Both and may contain nested ex-
|
|
pressions. To prevent a dollar sign from starting a nested ex-
|
|
pression, escape it with a backslash. The modifier works like
|
|
the modifier except that the old and new strings, instead of be-
|
|
ing simple strings, are an extended regular expression (see and
|
|
an Normally, the first occurrence of the pattern in each word of
|
|
the value is substituted with The modifier causes the substitu-
|
|
tion to apply to at most one word; the modifier causes the sub-
|
|
stitution to apply to as many instances of the search pattern as
|
|
occur in the word or words it is found in; the modifier causes
|
|
the value to be treated as a single word (possibly containing em-
|
|
bedded whitespace). As for the modifier, the and are subjected
|
|
to variable expansion before being parsed as regular expressions.
|
|
Replaces each word with its last path component (basename). Re-
|
|
moves adjacent duplicate words (like If the variable name (not
|
|
its value), when parsed as a conditional expression, evaluates to
|
|
true, return as its value the otherwise return the Since the
|
|
variable name is used as the expression, :? must be the first
|
|
modifier after the variable name which, of course, usually con-
|
|
tains variable expansions. A common error is trying to use ex-
|
|
pressions like which actually tests defined(NUMBERS). To deter-
|
|
mine if any words match you need to use something like: This is
|
|
the style substitution. It can only be the last modifier speci-
|
|
fied, as a in either or is treated as a regular character, not as
|
|
the end of the modifier. If does not contain the pattern match-
|
|
ing character and the word ends with or equals it, that suffix is
|
|
replaced with Otherwise, the first in matches a possibly empty
|
|
substring of arbitrary characters, and if the whole pattern is
|
|
found in the word, the matching part is replaced with and the
|
|
first occurrence of in (if any) is replaced with the substring
|
|
matched by the Both and may contain nested expressions. To pre-
|
|
vent a dollar sign from starting a nested expression, escape it
|
|
with a backslash. This is the loop expansion mechanism from the
|
|
OSF Development Environment (ODE) make. Unlike loops, expansion
|
|
occurs at the time of reference. For each word in the value, as-
|
|
sign the word to the variable named and evaluate The ODE conven-
|
|
tion is that should start and end with a period, for example:
|
|
However, a single-letter variable is often more readable: Saves
|
|
the current variable value in or the named for later reference.
|
|
Example usage: M_cmpv.units = 1 1000 1000000 M_cmpv = S,.,
|
|
,g:_:range:@i@+ $${_:[-$$i]} \ \*
|
|
$${M_cmpv.units:[$$i]}@:S,^,expr 0 ,1:sh
|
|
|
|
|
|
Here is used to save the result of the modifier which is later
|
|
referenced using the index values from If the variable is unde-
|
|
fined, the optional (which may be empty) is the value. If the
|
|
variable is defined, the existing value is returned. This is an-
|
|
other ODE make feature. It is handy for setting per-target
|
|
CFLAGS for instance: If a value is only required if the variable
|
|
is undefined, use: If the variable is defined, (which may be
|
|
empty) is the value. The name of the variable is the value. 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, the name of
|
|
the variable is used. In order for this modifier to work, the
|
|
name (node) must at least have appeared on the right-hand side of
|
|
a dependency. The output of running is the value. The value is
|
|
run as a command, and the output becomes the new value. The
|
|
variable is assigned the value after substitution. This modifier
|
|
and its variations are useful in obscure situations such as want-
|
|
ing to set a variable at a point where a target's shell commands
|
|
are being parsed. These assignment modifiers always expand to
|
|
nothing. The helps avoid false matches with the style modifier
|
|
and since substitution always occurs, the form is vaguely appro-
|
|
priate. As for but only if the variable does not already have a
|
|
value. Append to the variable. Assign the output of to the
|
|
variable. Selects one or more words from the value, or performs
|
|
other operations related to the way in which the value is split
|
|
into words. An empty value, or a value that consists entirely of
|
|
white-space, is treated as a single word. For the purposes of
|
|
the 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 is subjected to variable expansion, and the expanded
|
|
result is then interpreted as follows: Selects a single word from
|
|
the value. Selects all words from to inclusive. For example,
|
|
selects all words from the second word to the last word. If is
|
|
greater than the words are output in reverse order. For example,
|
|
selects all the words from last to first. If the list is already
|
|
ordered, this effectively reverses the list, but it is more effi-
|
|
cient to use instead of Causes subsequent modifiers to treat the
|
|
value as a single word (possibly containing embedded whitespace).
|
|
Analogous to the effect of in Bourne shell. Means the same as
|
|
Causes subsequent modifiers to treat the value as a sequence of
|
|
words delimited by whitespace. Analogous to the effect of in
|
|
Bourne shell. Returns the number of words in the value. offers
|
|
directives for including makefiles, conditionals and for loops.
|
|
All these directives are identified by a line beginning with a
|
|
single dot character, followed by the keyword of the directive,
|
|
such as or Files are included with either or Variables between
|
|
the angle brackets or double quotes are expanded to form the file
|
|
name. If angle brackets are used, the included makefile is ex-
|
|
pected to be in the system makefile directory. If double quotes
|
|
are used, the including makefile's directory and any directories
|
|
specified using the option are searched before the system make-
|
|
file directory. For compatibility with other make variants,
|
|
(without leading dot) is also accepted. If the include statement
|
|
is written as or as errors locating and/or opening include files
|
|
are ignored. If the include statement is written as not only are
|
|
errors locating and/or opening include files ignored, but stale
|
|
dependencies within the included file are ignored just like in
|
|
The directives for exporting and unexporting variables are: Ex-
|
|
port the specified global variable. If no variable list is pro-
|
|
vided, all globals are exported except for internal variables
|
|
(those that start with This is not affected by the flag, so
|
|
should be used with caution. For compatibility with other make
|
|
programs, (without leading dot) is also accepted. Appending a
|
|
variable name to is equivalent to exporting a variable. The same
|
|
as except that the variable is not appended to This allows ex-
|
|
porting a value to the environment which is different from that
|
|
used by internally. The same as except that variables in the
|
|
value are not expanded. The opposite of The specified global is
|
|
removed from If no variable list is provided, all globals are un-
|
|
exported, and deleted. Unexport all globals previously exported
|
|
and clear the environment inherited from the parent. This opera-
|
|
tion causes a memory leak of the original environment, so should
|
|
be used sparingly. Testing for being 0 would make sense. Also
|
|
note that any variables which originated in the parent environ-
|
|
ment should be explicitly preserved if desired. For example:
|
|
PATH := ${PATH} Would result in an environment containing only
|
|
which is the minimal useful environment. Actually is also pushed
|
|
into the new environment. The directives for printing messages
|
|
to the output are: The message is printed along with the name of
|
|
the makefile and line number. The message prefixed by is printed
|
|
along with the name of the makefile and line number. The message
|
|
is printed along with the name of the makefile and line number,
|
|
exits immediately. The directives for conditionals are: Test the
|
|
value of an expression. Test whether a variable is defined.
|
|
Test whether a variable is not defined. Test the target being
|
|
requested. Test the target being requested. Reverse the sense
|
|
of the last conditional. A combination of followed by A combina-
|
|
tion of followed by A combination of followed by A combination of
|
|
followed by A combination of followed by End the body of the con-
|
|
ditional. The may be any one of the following: Logical OR. Log-
|
|
ical AND; of higher precedence than only evaluates a conditional
|
|
as far as is necessary to determine its value. Parentheses can
|
|
be used to override the operator precedence. The boolean opera-
|
|
tor may be used to logically negate an expression, typically a
|
|
function call. It is of higher precedence than The value of may
|
|
be any of the following function call expressions: Evaluates to
|
|
true if the variable has been defined. Evaluates to true if the
|
|
target was specified as part of command line or was declared the
|
|
default target (either implicitly or explicitly, see before the
|
|
line containing the conditional. Evaluates to true if the expan-
|
|
sion of the variable, after applying the modifiers, results in an
|
|
empty string. Evaluates to true if the given pathname exists.
|
|
If relative, the pathname is searched for on the system search
|
|
path (see Evaluates to true if the target has been defined.
|
|
Evaluates to true if the target has been defined and has commands
|
|
associated with it. may also be an arithmetic or string compari-
|
|
son. Variable expansion is performed on both sides of the com-
|
|
parison. If both sides are numeric and neither is enclosed in
|
|
quotes, the comparison is done numerically, otherwise lexico-
|
|
graphically. A string is interpreted as a hexadecimal integer if
|
|
it is preceded by otherwise it is interpreted as a decimal float-
|
|
ing-point number; octal numbers are not supported. All compar-
|
|
isons may use the operators and Numeric comparisons may also use
|
|
the operators and If the comparison has neither a comparison op-
|
|
erator nor a right side, the expression evaluates to true if it
|
|
is nonempty and its numeric value (if any) is not zero. When is
|
|
evaluating one of these conditional expressions, and it encoun-
|
|
ters a (whitespace-separated) word it doesn't recognize, either
|
|
the or function is applied to it, depending on the form of the
|
|
conditional. If the form is or the function is applied. Simi-
|
|
larly, if the form is or the function is applied. If the condi-
|
|
tional evaluates to true, parsing of the makefile continues as
|
|
before. If it evaluates to false, the following lines until the
|
|
corresponding variant, or are skipped. For loops are typically
|
|
used to apply a set of rules to a list of files. The syntax of a
|
|
for loop is: The is expanded and then split into words. On each
|
|
iteration of the loop, one word is taken and assigned to each in
|
|
order, and these are substituted into the 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. If is encountered within a loop, it
|
|
causes early termination of the loop, otherwise a parse error.
|
|
Un-define the specified global variables. Only global variables
|
|
can be un-defined. Comments begin with a hash character, any-
|
|
where but in a shell command line, and continue to the end of an
|
|
unescaped new line. Target is never out of date, but always exe-
|
|
cute commands anyway. Ignore any errors from the commands asso-
|
|
ciated with this target, exactly as if they all were preceded by
|
|
a dash Mark all sources of this target as being up to date. Exe-
|
|
cute the commands associated with this target even if the or op-
|
|
tions were specified. Normally used to mark recursive Create a
|
|
meta file for the target, even if it is flagged as or Usage in
|
|
conjunction with is the most likely case. In mode, the target is
|
|
out-of-date if the meta file is missing. Do not create a meta
|
|
file for the target. Meta files are also not created for or tar-
|
|
gets. Ignore differences in commands when deciding if target is
|
|
out of date. This is useful if the command contains a value
|
|
which always changes. If the number of commands change, though,
|
|
the target is still considered out of date. The same effect ap-
|
|
plies to any command line that uses the variable which can be
|
|
used for that purpose even when not otherwise needed or desired:
|
|
|
|
skip-compare-for-some: @echo this is compared
|
|
@echo this is not ${.OODATE:M.NOMETA_CMP} @echo
|
|
this is also compared
|
|
|
|
The pattern suppresses any expansion of the unwanted variable.
|
|
Do not search for the target in the directories specified by Nor-
|
|
mally selects the first target it encounters as the default tar-
|
|
get to be built if no target was specified. This source prevents
|
|
this target from being selected. If a target is marked with this
|
|
attribute and can't figure out how to create it, it ignores this
|
|
fact and assumes the file isn't needed or already exists. The
|
|
target does not correspond to an actual file; it is always con-
|
|
sidered to be out of date, and is not created with the option.
|
|
Suffix-transformation rules are not applied to targets. When is
|
|
interrupted, it normally removes any partially made targets.
|
|
This source prevents the target from being removed. Synonym for
|
|
Do not echo any of the commands associated with this target, ex-
|
|
actly as if they all were preceded by an at sign Turn the target
|
|
into version of a macro. When the target is used as a source for
|
|
another target, the other target acquires the commands, sources,
|
|
and attributes (except for of the source. If the target already
|
|
has commands, the target's commands are appended to them. Like
|
|
but instead of appending, prepend the target commands to the tar-
|
|
get. If appears in a dependency line, the sources that precede
|
|
it are made before the sources that succeed it in the line.
|
|
Since the dependents of files are not made until the file itself
|
|
could be made, this also stops the dependents being built unless
|
|
they are needed for another branch of the dependency tree. So
|
|
given: x: a .WAIT b echo x a: echo a b: b1
|
|
echo b b1: echo b1
|
|
|
|
the output is always The ordering imposed by is only relevant for
|
|
parallel makes. Special targets may not be included with other
|
|
targets, i.e. they must be the only target specified. Any com-
|
|
mand lines attached to this target are executed before anything
|
|
else is done. This is sort of a rule for any target (that was
|
|
used only as a source) that can't figure out any other way to
|
|
create. Only the shell script is used. The variable of a target
|
|
that inherits commands is set to the target's own name. If this
|
|
target is present in the makefile, it globally causes make to
|
|
delete targets whose commands fail. (By default, only targets
|
|
whose commands are interrupted during execution are deleted.
|
|
This is the historical behavior.) This setting can be used to
|
|
help prevent half-finished or malformed targets from being left
|
|
around and corrupting future rebuilds. Any command lines at-
|
|
tached to this target are executed after everything else is done
|
|
successfully. Any command lines attached to this target are exe-
|
|
cuted when another target fails. See for the variables that will
|
|
be set. Mark each of the sources with the attribute. If no
|
|
sources are specified, this is the equivalent of specifying the
|
|
option. If is interrupted, the commands for this target are exe-
|
|
cuted. If no target is specified when is invoked, this target is
|
|
built. This target provides a way to specify flags for at the
|
|
time when the makefiles are read. The flags are as if typed to
|
|
the shell, though the option has no effect. Apply the attribute
|
|
to any specified sources. Disable parallel mode. Synonym for
|
|
for compatibility with other pmake variants. clear the read-only
|
|
attribute from the global variables specified as sources. The
|
|
source is a new value for If it exists, changes the current work-
|
|
ing directory to it and updates the value of In parallel mode,
|
|
the named targets are made in sequence. This ordering does not
|
|
add targets to the list of targets to be made. Since the depen-
|
|
dents of a target do not get built until the target itself could
|
|
be built, unless is built by another part of the dependency
|
|
graph, the following is a dependency loop: .ORDER: b a b: a The
|
|
sources are directories which are to be searched for files not
|
|
found in the current directory. If no sources are specified, any
|
|
previously specified directories are removed from the search
|
|
path. If the source is the special target, the current working
|
|
directory is searched last. Like but applies only to files with
|
|
a particular suffix. The suffix must have been previously de-
|
|
clared with Apply the attribute to any specified sources. If
|
|
this is the first non-comment line in the main makefile, the
|
|
variable is set to the value and the makefile is included if it
|
|
exists, to provide POSIX-compatible default rules. If is run
|
|
with the flag, only contributes to the default rules. Apply the
|
|
attribute to any specified sources. If no sources are specified,
|
|
the attribute is applied to every target in the file. set the
|
|
read-only attribute on the global variables specified as sources.
|
|
Sets the shell that uses to execute commands. The sources are a
|
|
set of pairs. This is the minimal specification, used to select
|
|
one of the built-in shell specs; and Specifies the absolute path
|
|
to the shell. Indicates whether the shell supports exit on er-
|
|
ror. The command to turn on error checking. The command to dis-
|
|
able error checking. The command to turn on echoing of commands
|
|
executed. The command to turn off echoing of commands executed.
|
|
The output to filter after issuing the command. It is typically
|
|
identical to The flag to pass the shell to enable error checking.
|
|
The flag to pass the shell to enable command echoing. The string
|
|
literal to pass the shell that results in a single newline char-
|
|
acter when used outside of any quoting characters. Example:
|
|
.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'" Apply the attribute to any specified sources. If
|
|
no sources are specified, the attribute is applied to every com-
|
|
mand in the file. This target gets run when a dependency file
|
|
contains stale entries, having set to the name of that dependency
|
|
file. Each source specifies a suffix to If no sources are speci-
|
|
fied, any previously specified suffixes are deleted. It allows
|
|
the creation of suffix-transformation rules. Example: .SUFFIXES:
|
|
.c .o .c.o: cc -o ${.TARGET} -c ${.IMPSRC} The sources
|
|
are directories which are to be added to the system include path
|
|
which searches for makefiles. If no sources are specified, any
|
|
previously specified directories are removed from the system in-
|
|
clude path. uses the following environment variables, if they
|
|
exist: and and may only be set in the environment or on the com-
|
|
mand line to and not as makefile variables; see the description
|
|
of for more details. list of dependencies first default makefile
|
|
if no makefile is specified on the command line second default
|
|
makefile if no makefile is specified on the command line system
|
|
makefile system makefile directory The basic make syntax is com-
|
|
patible between different make variants; however the special
|
|
variables, variable modifiers and conditionals are not. An in-
|
|
complete list of changes in older versions of The way that .for
|
|
loop variables are substituted changed after NetBSD 5.0 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 4.0 so that .ORDER and
|
|
.WAIT apply recursively to the dependent nodes. The algorithms
|
|
used may change again in the future. Other make dialects (GNU
|
|
make, SVR4 make, POSIX make, etc.) do not support most of the
|
|
features of as described in this manual. Most notably: The and
|
|
declarations and most functionality pertaining to paralleliza-
|
|
tion. (GNU make supports parallelization but lacks the 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 and Variable modifiers, except for
|
|
the string substitution, which does not portably support globbing
|
|
with and historically only works on declared suffixes. The vari-
|
|
able even in its short form; most makes support this functional-
|
|
ity but its name varies. Some features are somewhat more
|
|
portable, such as assignment with and The functionality is based
|
|
on an older feature 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 uni-
|
|
versally portable, as is the variable. Basic use of suffix rules
|
|
(for files only in the current directory, not trying to chain
|
|
transformations together, etc.) is also reasonably portable. is
|
|
derived from NetBSD It uses autoconf to facilitate portability to
|
|
other platforms. A make command appeared in This make implemen-
|
|
tation is based on Adam de Boor's pmake program, which was writ-
|
|
ten for Sprite at Berkeley. It was designed to be a parallel
|
|
distributed make running jobs on different machines using a dae-
|
|
mon called Historically the target/dependency has been used to
|
|
FoRCe rebuilding (since the target/dependency does not exist ...
|
|
unless someone creates an file). The make syntax is difficult to
|
|
parse. For instance, finding the end of a variable's use should
|
|
involve scanning each of the modifiers, using the correct termi-
|
|
nator for each field. In many places make just counts {} and ()
|
|
in order to find the end of a variable expansion. There is no
|
|
way of escaping a space character in a filename. In jobs mode,
|
|
when a target fails; make will put an error token into the job
|
|
token pool. This will cause all other instances of make using
|
|
that token pool to abort the build and exit with error code 6.
|
|
Sometimes the attempt to suppress a cascade of unnecessary er-
|
|
rors, can result in a seemingly unexplained
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|