| MAKE(1) | General Commands Manual | MAKE(1) | 
make —
| make | [ -BeikNnqrstWwX] [-Cdirectory] [-Dvariable] [-dflags] [-fmakefile] [-Idirectory] [-Jprivate] [-jmax_jobs] [-mdirectory] [-Tfile] [-Vvariable] [-vvariable] [variable=value]
      [target ...] | 
make is a program designed to simplify the maintenance
  of other programs. Its input is a list of specifications as to the files upon
  which programs and other files depend. If no -f
  makefile makefile option is given,
  make will try to open
  ‘makefile’ then
  ‘Makefile’ in
  order to find the specifications. If the file
  ‘.depend’
  exists, it is read (see
  mkdep(1)).
This manual page is intended as a reference document only. For a
    more thorough description of make and makefiles,
    please refer to PMake - A Tutorial.
make will prepend the contents of the
    MAKEFLAGS environment variable to the command line
    arguments before parsing them.
The options are as follows:
-B-C
    directory-C options are
      specified, each is interpreted relative to the previous one:
      -C /
      -C etc is equivalent to
      -C /etc.-D
    variable-d
    [-]flagsmake are to print debugging information. Unless
      the flags are preceded by ‘-’ they
      are added to the MAKEFLAGS environment variable and
      will be processed by any child make processes. By default, debugging
      information is printed to standard error, but this can be changed using
      the F debugging flag. The debugging output is always
      unbuffered; in addition, if debugging is enabled but debugging output is
      not directed to standard output, then the standard output is line
      buffered. Flags is one or more of the following:
    F’ flag
          is ‘+’, then the file will be
          opened in append mode; otherwise the file will be overwritten. If the
          file name is ‘stdout’ or
          ‘stderr’ then debugging output
          will be written to the standard output or standard error output file
          descriptors respectively (and the
          ‘+’ option has no effect).
          Otherwise, the output will be written to the named file. If the file
          name ends ‘.%d’ then the
          ‘%d’ is replaced by the
        pid.@’ or other
          "quiet" flags. Also known as "loud" behavior.TMPDIR environment
          variable, or in /tmp if
          TMPDIR is unset or set to the empty string.
          The temporary scripts are created by
          mkstemp(3), and have
          names of the form makeXXXXXX.
          NOTE: This can create many files in
          TMPDIR or /tmp, so use
          with care.-V option to print raw values of
          variables, overriding the default behavior set via
          .MAKE.EXPAND_VARIABLES.-x so the actual
          commands are printed as they are executed.-e-f
    makefilemakefile’.
      If makefile is
      ‘--I
    directory-m option) is automatically included as part of
      this list.-i--J
    privateWhen the j 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.
-j
    max_jobsmake may
      have running at any one time. The value is saved in
      .MAKE.JOBS. Turns compatibility mode off, unless the
      B flag is also specified. When compatibility mode is
      off, all commands associated with a target are executed in a single shell
      invocation as opposed to the traditional 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.-k-m
    directory-m option can be used multiple
      times to form a search path. This path will override the default system
      include path: /usr/share/mk. Furthermore the system include path will be
      appended to the search path used for
      “file”-style include statements (see
      the -I option).
    If a file or directory name in the -m
        argument (or the MAKESYSPATH environment
        variable) starts with the string “.../” then
        make will search for the specified file or
        directory named in the remaining part of the argument string. The search
        starts with the current directory of the Makefile and then works upward
        towards the root of the file system. If the search is successful, then
        the resulting directory replaces the “.../” specification
        in the -m argument. If used, this feature allows
        make to easily search in the current source tree
        for customized sys.mk files (e.g., by using
        “.../mk/sys.mk” as an argument).
-n-N-q-r-s@-T
    tracefile-j flag, append a trace record
      to tracefile for each job started and
    completed.-t-V
    variable$’ then the value will be
      recursively expanded to its complete resultant text before printing. The
      expanded value will also be printed if
      .MAKE.EXPAND_VARIABLES is set to true and the
      -dV option has not been used to override it. Note
      that loop-local and target-local variables, as well as values taken
      temporarily by global variables during makefile processing, are not
      accessible via this option. The -dv debug mode can
      be used to see these at the cost of generating substantial extraneous
      output.-v
    variable-V but the variable is always expanded to its
      complete value.-W-w-X-X flag disables this behavior. Variable
      assignments should follow options for POSIX compatibility but no ordering
      is enforced.There are seven different types of lines in a makefile: file dependency specifications, shell commands, variable assignments, include statements, conditional directives, for loops, and comments.
In general, 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.
:make is interrupted.!make is interrupted.::make is interrupted.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 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.
::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
    ‘@+-@+-n is given. This
    is similar to the effect of the .MAKE special source, except that the effect
    can be limited to a single line of a script. A
    ‘-
When make is run in jobs mode with
    -j max_jobs, the entire 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 characters
    (‘#=|^(){};&<>*?[]:$`\\n’)
    it will be passed to the shell; otherwise make will
    attempt direct execution. If a line starts with
    ‘--
Makefiles should be written so that the mode of
    make operation does not change their behavior. For
    example, any command which needs to use “cd” or
    “chdir” without potentially changing the directory for
    subsequent commands should be put in parentheses so it executes in a
    subshell. To force the use of one shell, escape the line breaks so as to
    make the whole script one command. For example:
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 make will
    chdir(2) to
    ‘.OBJDIR’ before
    executing any targets, each child process starts with that as its current
    working directory.
=+=?=:=!=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 (‘$’). 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, parenthesis, or whitespace are really best avoided!
If the result of expanding a variable contains a dollar sign
    (‘$’) the string is expanded
  again.
Variable substitution occurs at three distinct times, depending on where the variable is being used.
.for i in 1 2 3a+= ${i} j= ${i} b+= ${j}.endforall: @echo ${a} @echo ${b}
1 2 3
3 3 3
    
    make's
    environment.Local variables are all built in and their values vary magically from target to target. It is not currently possible to define new local variables. The seven local variables are as follows:
>’.!’.<’. It is
      not defined in explicit rules.%’.?’.*’. The
      suffix must be one of the known suffixes declared with
      .SUFFIXES or it will not be recognized.@’. For
      compatibility with other makes this is an alias for
      .ARCHIVE in archive member rules.The shorter forms
    (‘>’,
    ‘!’,
    ‘<’,
    ‘%’,
    ‘?’,
    ‘*’, 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 System V
    UNIX 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’.
make sets or knows about the following
  variables:
$’, i.e.
      ‘$$’ expands to a single dollar
      sign.make was executed.
      Refer to the description of
      ‘PWDMAKEmake was executed with
      (argv[0]). For compatibility
      make also sets .MAKE with
      the same value. The preferred variable to use is the environment variable
      MAKE because it is more compatible with other
      versions of make and cannot be confused with the
      special target with the same name..depend’)
      from which generated dependencies are read.-V option. If true, variable values printed with
      -V are fully expanded; if false, the raw variable
      contents (which may include additional unexpanded variable references) are
      shown.make.-j option.make is run with j then
      output for each target is prefixed with a token
      ‘--- target ---’ the first part of
      which can be controlled via .MAKE.JOB.PREFIX. If
      .MAKE.JOB.PREFIX is empty, no token is printed.
    .MAKE.JOB.PREFIX=${.newline}---${.MAKE:T}[${.MAKE.PID}]
      would produce tokens like ‘---make[1234] target
      ---’ making it easier to track the degree of parallelism
      being achieved.MAKEFLAGSMAKEFLAGSmake's command line. Anything specified on
      make's command line is appended to the
      ‘MAKEFLAGSmake executes.make. The initial instance
      of make will be 0, and an incremented value is put
      into the environment to be seen by the next generation. This allows tests
      like: .if ${.MAKE.LEVEL} == 0 to protect things
      which should only be evaluated in the initial instance of
      make.makefile’,
      ‘Makefile’)
      that make will look for.make, which is
      useful for tracking dependencies. Each makefile is recorded only once,
      regardless of the number of times read.make runs in. It can contain a number of keywords:
    -B, puts make
          into "compat" mode.make into "meta" mode, where
          meta files are created for each target to capture the command run, the
          output generated and if
          filemon(4) is
          available, the system calls which are of interest to
          make. The captured output can be very useful
          when diagnosing errors.make will not create .meta files in
          ‘.CURDIR’.
          This can be overridden by setting bf to a value
          which represents True..NOMETA_CMP..SILENT.make. If a file that was
      generated outside of .OBJDIR but within said
      bailiwick is missing, the current target is considered out-of-date./dev /etc /proc /tmp /var/run
      /var/tmp’Building
      ${.TARGET:H:tA}/${.TARGET:T}MAKEFLAGS.MAKEOVERRIDES’
      within a makefile. Extra variables can be exported from a makefile by
      appending their names to
      ‘.MAKEOVERRIDES’.
      ‘MAKEFLAGS.MAKEOVERRIDES’
      is modified.make was built with
      filemon(4) support, this is
      set to the path of the device node. This allows makefiles to test for this
      support.make.make.$$’ are preserved when doing
      ‘:=’ assignments. The default is
      true, for compatibility with other makes. If set to false,
      ‘$$’ becomes
      ‘$’ per normal evaluation
    rules.make stops due to an error, it sets
      ‘.ERROR_TARGET’
      to the name of the target that failed,
      ‘.ERROR_CMD’
      to the commands of the failed target, and in "meta" mode, it
      also sets
      ‘.ERROR_CWD’
      to the getcwd(3), and
      ‘.ERROR_META_FILE’
      to the path of the meta file (if any) describing the failed target. It
      then prints its name and the value of
      ‘.CURDIR’ as
      well as the value of any variables named in
      ‘MAKE_PRINT_VAR_ON_ERROR’.:@ modifier to put a
      newline between iterations of the loop rather than a space. For example,
      the printing of
      ‘MAKE_PRINT_VAR_ON_ERROR’
      could be done as
    ${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}.${MAKEOBJDIRPREFIX}${.CURDIR}
        (Only if
            ‘MAKEOBJDIRPREFIX
${MAKEOBJDIR}
        (Only if
            ‘MAKEOBJDIR
${.CURDIR}/obj.${MACHINE}${.CURDIR}/obj${.CURDIR}${.CURDIR}Variable expansion is performed on the value before it's used, so expressions such as
${.CURDIR:S,^/usr/src,/var/obj,}MAKEOBJDIR‘.OBJDIR’
        may be modified in the makefile via the special target
        ‘.OBJDIRmake will
        chdir(2) to the specified
        directory if it exists, and set
        ‘.OBJDIR’
        and ‘PWD
Makefile’
      being parsed.Makefile’
      being parsed. This variable and
      ‘.PARSEDIR’
      are both set only while the
      ‘Makefiles’
      are being parsed. If you want to retain their current values, assign them
      to a variable using assignment with expansion:
      (‘:=make will search for files. The search list should
      be updated using the target
      ‘.PATH’ rather
      than the variable.PWDmake
      normally sets
      ‘.CURDIR’ to
      the canonical path given by
      getcwd(3). However, if the
      environment variable
      ‘PWDmake sets
      ‘.CURDIR’ to
      the value of
      ‘PWDMAKEOBJDIRPREFIXMAKEOBJDIRPWD.OBJDIR’ for
      all programs which make executes..TARGETSVPATHmake will search for files. The variable is
      supported for compatibility with old make programs only, use
      ‘.PATH’
      instead.${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:
:E:H:Mpattern*’,
      ‘?’, 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*}:Npattern:M:O:O:[-1..1]:Ox:=
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}"
    
    
quattro due tre uno
tre due quattro uno
due uno quattro tre
due uno quattro tre
    
    :Q:qmake. This is equivalent
      to: ‘:S/\$/&&/g:Q’.:R:range[=count]:gmtime[=utc]:hash:localtime[=utc]:tA:tl:tsc:tu:tW:[*]:tw:[@]:S/old_string/new_string/[1gW]g’ is appended to the last slash of
      the pattern, all occurrences in each word are replaced. If a
      ‘1’ is appended to the last slash of
      the pattern, only the first word is affected. If a
      ‘W’ is appended to the last slash 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
      (‘$’), it is anchored at the end of
      each word. Inside new_string, an ampersand
      (‘&’) is replaced by
      old_string (without any
      ‘^’ or
      ‘$’). 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 (‘$’),
        not a preceding dollar sign as is usual.
:C/pattern/replacement/[1gW]:C modifier is just like the
      :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). Note that ‘1’ and
      ‘g’ are orthogonal; the former
      specifies whether multiple words are potentially affected, the latter
      whether multiple substitutions can potentially occur within each affected
      word.
    As for the :S modifier, the
        pattern and replacement are
        subjected to variable expansion before being parsed as regular
        expressions.
:T:u:?true_string:false_string${NUMBERS:M42:?match:no}${"${NUMBERS:M42}" !=
      "":?match:no}.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 (‘$’),
        not a preceding dollar sign as is usual.
:@temp@string@.for loops expansion occurs at
      the time of reference. Assign temp to each word in
      the variable and evaluate 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}@}:_[=var]$_’ or the named
      var 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
.if ${VERSION:${M_cmpv}} < ${3.1.12:L:${M_cmpv}}
    
    $_’ is used to save the result
      of the ‘:S’ modifier which is later
      referenced using the index values from
      ‘:range’.:Unewval${_${.TARGET:T}_CFLAGS:U${DEF_CFLAGS}}${VAR:D:Unewval}:Dnewval:L:P:!cmd!:sh::=strmake happy.
    The
        ‘:::= modifier and since
        substitution always occurs the ::= form is
        vaguely appropriate.
::?=str::= but only if the variable does not
      already have a value.::+=str::!=cmd:[range]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
        ‘:[]
The range is subjected to variable expansion, and the expanded result is then interpreted as follows:
..end:[2..-1]:[-1..1]*:[*]@#make. All such
  structures are identified by a line beginning with a single dot
  (‘.’) character. Files are included with
  either .include
  ⟨file⟩ or .include
  "file". Variables between the angle brackets
  or double quotes are expanded to form the file name. If angle brackets are
  used, the included makefile is expected to be in the system makefile
  directory. If double quotes are used, the including makefile's directory and
  any directories specified using the -I option are
  searched before the system makefile directory. For compatibility with other
  versions of make ‘include file
  ...’ is also accepted.
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
    messagemake will exit..export
    variable ....’). 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 ....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 ....export-env’, except
      that variables in the value are not expanded..info
    message.undef
    variable.unexport
    variable ....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.if ${.MAKE.LEVEL} == 0PATH := ${PATH}.unexport-env.export PATH.endif
PATH.MAKE.LEVEL.warning
    messagewarning:’
      is printed along with the name of the makefile and line number..if
    [!]expression [operator expression
    ...].ifdef
    [!]variable [operator variable
    ...].ifndef
    [!]variable [operator variable
    ...].ifmake
    [!]target [operator target
    ...].ifnmake
    [!] target [operator target
    ...].else.elif
    [!] expression [operator expression
    ...].else.if.elifdef
    [!]variable [operator variable
    ...].else.ifdef.elifndef
    [!]variable [operator variable
    ...].else.ifndef.elifmake
    [!]target [operator target
    ...].else.ifmake.elifnmake
    [!]target [operator target
    ...].else.ifnmake.endifThe operator may be any one of the following:
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
    ‘!&&
The value of expression may be any of the following:
definedmakemake's command line or was
      declared the default target (either implicitly or explicitly, see
      .MAIN) before the line containing the
    conditional.emptyexiststargetcommandsExpression may also be an arithmetic or
    string comparison. Variable expansion is performed on both sides of the
    comparison, after which the integral 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 ‘==!=
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.if.ifmake.ifnmake
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.endif
For loops are typically used to apply a set of rules to a list of files. The syntax of a for loop is:
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-rules 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.
#’)
  character, anywhere but in a shell command line, and continue to the end of an
  unescaped new line.
.EXEC.IGNORE-’)..MADE.MAKE-n or -t options were
      specified. Normally used to mark recursive
    makes..META.PHONY, .MAKE, or
      .SPECIAL. Usage in conjunction with
      .MAKE is the most likely case. In "meta"
      mode, the target is out-of-date if the meta file is missing..NOMETA.PHONY, .MAKE, or
      .SPECIAL targets..NOMETA_CMP
skip-compare-for-some:
	@echo this will be compared
	@echo this will not ${.OODATE:M.NOMETA_CMP}
	@echo this will also be compared
    
    :M pattern suppresses any expansion of the
      unwanted variable..NOPATH.PATH..NOTMAINmake selects the first target it
      encounters as the default target to be built if no target was specified.
      This source prevents this target from being selected..OPTIONALmake
      can't figure out how to create it, it will ignore this fact and assume the
      file isn't needed or already exists..PHONY-t option. Suffix-transformation rules are not
      applied to .PHONY targets..PRECIOUSmake is interrupted, it normally removes any
      partially made targets. This source prevents the target from being
      removed..RECURSIVE.MAKE..SILENT@’)..USEmake's 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
      .USE) of the source. If the target already has
      commands, the .USE target's commands are appended
      to them..USEBEFORE.USE, but prepend the
      .USEBEFORE target commands to the target..WAIT.WAIT 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
    
    a’,
      ‘b1’,
      ‘b’,
      ‘x’.
    .WAIT is only relevant for
      parallel makes..BEGIN.DEFAULT.USE rule for any target (that
      was used only as a source) that make can't figure
      out any other way to create. Only the shell script is used. The
      .IMPSRC variable of a target that inherits
      .DEFAULT's commands is set to the target's own
      name..DELETE_ON_ERROR.END.ERROR.ERROR_TARGET variable is set to the
      target that failed. See also
      MAKE_PRINT_VAR_ON_ERROR..IGNORE.IGNORE
      attribute. If no sources are specified, this is the equivalent of
      specifying the -i option..INTERRUPTmake is interrupted, the commands for this
      target will be executed..MAINmake is invoked,
      this target will be built..MAKEFLAGSmake when the makefile is used. The flags are as
      if typed to the shell, though the -f option will
      have no effect..NOPATH.NOPATH attribute to any specified
      sources..NOTPARALLEL.NO_PARALLEL.NOTPARALLEL, for compatibility with
      other pmake variants..OBJDIR.OBJDIR’. If
      it exists, make will
      chdir(2) to it and update the
      value of
      ‘.OBJDIR’..ORDERa’ is built by another part of the
      dependency graph, the following is a dependency loop:
    
.ORDER: b a
b: a
    
    The ordering imposed by .ORDER is only
        relevant for parallel makes.
.PATH.DOTLAST target, then the current working
      directory is searched last..PATH.suffix.PATH but applies only to files with a
      particular suffix. The suffix must have been previously declared with
      .SUFFIXES..PHONY.PHONY attribute to any specified
      sources..PRECIOUS.PRECIOUS attribute to any specified
      sources. If no sources are specified, the
      .PRECIOUS attribute is applied to every target in
      the file..SHELLmake will use to execute
      commands. The sources are a set of field=value
      pairs.
    
.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'"
    
    .SILENT.SILENT attribute to any specified
      sources. If no sources are specified, the .SILENT
      attribute is applied to every command in the file..STALE.SUFFIXESmake. If no
      sources are specified, any previously specified suffixes are deleted. It
      allows the creation of suffix-transformation rules.
    Example:
.SUFFIXES: .o
.c.o:
	cc -o ${.TARGET} -c ${.IMPSRC}
    
    make uses the following environment variables, if they
  exist: MACHINE, MACHINE_ARCH,
  MAKE, MAKEFLAGS,
  MAKEOBJDIR, MAKEOBJDIRPREFIX,
  MAKESYSPATH, PWD, and
  TMPDIR.
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.
make:
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.
make as described in this manual.
  Most notably:
.WAIT and .ORDER
      declarations and most functionality pertaining to parallelization. (GNU
      make supports parallelization but lacks these features needed to control
      it effectively.).PHONY,
      .PRECIOUS, and
    .SUFFIXES.:old=new%’ and historically only works on
      declared suffixes.$> 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.
make command appeared in
  Version 7 AT&T UNIX. This
  make implementation is based on Adam De Boor's pmake
  program which was written for Sprite at Berkeley. It was designed to be a
  parallel distributed make running jobs on different machines using a daemon
  called “customs”.
Historically the target/dependency “FRC” has been used to FoRCe rebuilding (since the target/dependency does not exist... unless someone creates an “FRC” file).
make syntax is difficult to parse without actually
  acting on the data. For instance, finding the end of a variable's use should
  involve scanning each of the modifiers, using the correct terminator 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.
| February 16, 2019 | NetBSD 9.4 |