contrib/bmake/bmake.cat1

   1 BMAKE(1)                FreeBSD General Commands Manual               BMAKE(1)
   2
   3 \e[1mNAME\e[0m
   4      \e[1mbmake \e[22m-- maintain program dependencies
   5
   6 \e[1mSYNOPSIS\e[0m
   7      \e[1mbmake \e[22m[\e[1m-BeikNnqrstWwX\e[22m] [\e[1m-C \e[4m\e[22mdirectory\e[24m] [\e[1m-D \e[4m\e[22mvariable\e[24m] [\e[1m-d \e[4m\e[22mflags\e[24m]
   8            [\e[1m-f \e[4m\e[22mmakefile\e[24m] [\e[1m-I \e[4m\e[22mdirectory\e[24m] [\e[1m-J \e[4m\e[22mprivate\e[24m] [\e[1m-j \e[4m\e[22mmax_jobs\e[24m]
   9            [\e[1m-m \e[4m\e[22mdirectory\e[24m] [\e[1m-T \e[4m\e[22mfile\e[24m] [\e[1m-V \e[4m\e[22mvariable\e[24m] [\e[1m-v \e[4m\e[22mvariable\e[24m]
  10            [\e[4mvariable=value\e[24m] [\e[4mtarget\e[24m \e[4m...\e[24m]
  11
  12 \e[1mDESCRIPTION\e[0m
  13      \e[1mbmake \e[22mis a program designed to simplify the maintenance of other pro-
  14      grams.  Its input is a list of specifications as to the files upon which
  15      programs and other files depend.  If no \e[1m-f \e[4m\e[22mmakefile\e[24m makefile option is
  16      given, \e[1mbmake \e[22mwill try to open `\e[4mmakefile\e[24m' then `\e[4mMakefile\e[24m' in order to find
  17      the specifications.  If the file `\e[4m.depend\e[24m' exists, it is read (see
  18      mkdep(1)).
  19
  20      This manual page is intended as a reference document only.  For a more
  21      thorough description of \e[1mbmake \e[22mand makefiles, please refer to \e[4mPMake\e[24m \e[4m-\e[24m \e[4mA\e[0m
  22      \e[4mTutorial\e[24m.
  23
  24      \e[1mbmake \e[22mwill prepend the contents of the \e[4mMAKEFLAGS\e[24m environment variable to
  25      the command line arguments before parsing them.
  26
  27      The options are as follows:
  28
  29      \e[1m-B      \e[22mTry to be backwards compatible by executing a single shell per
  30              command and by executing the commands to make the sources of a
  31              dependency line in sequence.
  32
  33      \e[1m-C \e[4m\e[22mdirectory\e[0m
  34              Change to \e[4mdirectory\e[24m before reading the makefiles or doing any-
  35              thing else.  If multiple \e[1m-C \e[22moptions are specified, each is inter-
  36              preted relative to the previous one: \e[1m-C \e[4m\e[22m/\e[24m \e[1m-C \e[4m\e[22metc\e[24m is equivalent to
  37              \e[1m-C \e[4m\e[22m/etc\e[24m.
  38
  39      \e[1m-D \e[4m\e[22mvariable\e[0m
  40              Define \e[4mvariable\e[24m to be 1, in the global context.
  41
  42      \e[1m-d \e[4m\e[22m[-]flags\e[0m
  43              Turn on debugging, and specify which portions of \e[1mbmake \e[22mare to
  44              print debugging information.  Unless the flags are preceded by
  45              `-' they are added to the \e[4mMAKEFLAGS\e[24m environment variable and will
  46              be processed by any child make processes.  By default, debugging
  47              information is printed to standard error, but this can be changed
  48              using the \e[4mF\e[24m debugging flag.  The debugging output is always
  49              unbuffered; in addition, if debugging is enabled but debugging
  50              output is not directed to standard output, then the standard out-
  51              put is line buffered.  \e[4mFlags\e[24m is one or more of the following:
  52
  53              \e[4mA\e[24m       Print all possible debugging information; equivalent to
  54                      specifying all of the debugging flags.
  55
  56              \e[4ma\e[24m       Print debugging information about archive searching and
  57                      caching.
  58
  59              \e[4mC\e[24m       Print debugging information about current working direc-
  60                      tory.
  61
  62              \e[4mc\e[24m       Print debugging information about conditional evaluation.
  63
  64              \e[4md\e[24m       Print debugging information about directory searching and
  65                      caching.
  66
  67              \e[4me\e[24m       Print debugging information about failed commands and
  68                      targets.
  69
  70              \e[4mF\e[24m[\e[1m+\e[22m]\e[4mfilename\e[0m
  71                      Specify where debugging output is written.  This must be
  72                      the last flag, because it consumes the remainder of the
  73                      argument.  If the character immediately after the `F'
  74                      flag is `+', then the file will be opened in append mode;
  75                      otherwise the file will be overwritten.  If the file name
  76                      is `stdout' or `stderr' then debugging output will be
  77                      written to the standard output or standard error output
  78                      file descriptors respectively (and the `+' option has no
  79                      effect).  Otherwise, the output will be written to the
  80                      named file.  If the file name ends `.%d' then the `%d' is
  81                      replaced by the pid.
  82
  83              \e[4mf\e[24m       Print debugging information about loop evaluation.
  84
  85              \e[4mg1\e[24m      Print the input graph before making anything.
  86
  87              \e[4mg2\e[24m      Print the input graph after making everything, or before
  88                      exiting on error.
  89
  90              \e[4mg3\e[24m      Print the input graph before exiting on error.
  91
  92              \e[4mj\e[24m       Print debugging information about running multiple
  93                      shells.
  94
  95              \e[4ml\e[24m       Print commands in Makefiles regardless of whether or not
  96                      they are prefixed by `@' or other "quiet" flags.  Also
  97                      known as "loud" behavior.
  98
  99              \e[4mM\e[24m       Print debugging information about "meta" mode decisions
 100                      about targets.
 101
 102              \e[4mm\e[24m       Print debugging information about making targets, includ-
 103                      ing modification dates.
 104
 105              \e[4mn\e[24m       Don't delete the temporary command scripts created when
 106                      running commands.  These temporary scripts are created in
 107                      the directory referred to by the TMPDIR environment vari-
 108                      able, or in \e[4m/tmp\e[24m if TMPDIR is unset or set to the empty
 109                      string.  The temporary scripts are created by mkstemp(3),
 110                      and have names of the form \e[4mmakeXXXXXX\e[24m.  \e[4mNOTE\e[24m: This can
 111                      create many files in TMPDIR or \e[4m/tmp\e[24m, so use with care.
 112
 113              \e[4mp\e[24m       Print debugging information about makefile parsing.
 114
 115              \e[4ms\e[24m       Print debugging information about suffix-transformation
 116                      rules.
 117
 118              \e[4mt\e[24m       Print debugging information about target list mainte-
 119                      nance.
 120
 121              \e[4mV\e[24m       Force the \e[1m-V \e[22moption to print raw values of variables,
 122                      overriding the default behavior set via
 123                      \e[4m.MAKE.EXPAND_VARIABLES\e[24m.
 124
 125              \e[4mv\e[24m       Print debugging information about variable assignment.
 126
 127              \e[4mx\e[24m       Run shell commands with \e[1m-x \e[22mso the actual commands are
 128                      printed as they are executed.
 129
 130      \e[1m-e      \e[22mSpecify that environment variables override macro assignments
 131              within makefiles.
 132
 133      \e[1m-f \e[4m\e[22mmakefile\e[0m
 134              Specify a makefile to read instead of the default `\e[4mmakefile\e[24m'.  If
 135              \e[4mmakefile\e[24m is `\e[1m-\e[22m', standard input is read.  Multiple makefiles may
 136              be specified, and are read in the order specified.
 137
 138      \e[1m-I \e[4m\e[22mdirectory\e[0m
 139              Specify a directory in which to search for makefiles and included
 140              makefiles.  The system makefile directory (or directories, see
 141              the \e[1m-m \e[22moption) is automatically included as part of this list.
 142
 143      \e[1m-i      \e[22mIgnore non-zero exit of shell commands in the makefile.  Equiva-
 144              lent to specifying `\e[1m-\e[22m' before each command line in the makefile.
 145
 146      \e[1m-J \e[4m\e[22mprivate\e[0m
 147              This option should \e[4mnot\e[24m be specified by the user.
 148
 149              When the \e[4mj\e[24m option is in use in a recursive build, this option is
 150              passed by a make to child makes to allow all the make processes
 151              in the build to cooperate to avoid overloading the system.
 152
 153      \e[1m-j \e[4m\e[22mmax_jobs\e[0m
 154              Specify the maximum number of jobs that \e[1mbmake \e[22mmay have running at
 155              any one time.  The value is saved in \e[4m.MAKE.JOBS\e[24m.  Turns compati-
 156              bility mode off, unless the \e[4mB\e[24m flag is also specified.  When com-
 157              patibility mode is off, all commands associated with a target are
 158              executed in a single shell invocation as opposed to the tradi-
 159              tional one shell invocation per line.  This can break traditional
 160              scripts which change directories on each command invocation and
 161              then expect to start with a fresh environment on the next line.
 162              It is more efficient to correct the scripts rather than turn
 163              backwards compatibility on.
 164
 165      \e[1m-k      \e[22mContinue processing after errors are encountered, but only on
 166              those targets that do not depend on the target whose creation
 167              caused the error.
 168
 169      \e[1m-m \e[4m\e[22mdirectory\e[0m
 170              Specify a directory in which to search for sys.mk and makefiles
 171              included via the <\e[4mfile\e[24m>-style include statement.  The \e[1m-m \e[22moption
 172              can be used multiple times to form a search path.  This path will
 173              override the default system include path: /usr/share/mk.  Fur-
 174              thermore the system include path will be appended to the search
 175              path used for "\e[4mfile\e[24m"-style include statements (see the \e[1m-I\e[0m
 176              option).
 177
 178              If a file or directory name in the \e[1m-m \e[22margument (or the
 179              MAKESYSPATH environment variable) starts with the string ".../"
 180              then \e[1mbmake \e[22mwill search for the specified file or directory named
 181              in the remaining part of the argument string.  The search starts
 182              with the current directory of the Makefile and then works upward
 183              towards the root of the file system.  If the search is success-
 184              ful, then the resulting directory replaces the ".../" specifica-
 185              tion in the \e[1m-m \e[22margument.  If used, this feature allows \e[1mbmake \e[22mto
 186              easily search in the current source tree for customized sys.mk
 187              files (e.g., by using ".../mk/sys.mk" as an argument).
 188
 189      \e[1m-n      \e[22mDisplay the commands that would have been executed, but do not
 190              actually execute them unless the target depends on the .MAKE spe-
 191              cial source (see below).
 192
 193      \e[1m-N      \e[22mDisplay the commands which would have been executed, but do not
 194              actually execute any of them; useful for debugging top-level
 195              makefiles without descending into subdirectories.
 196
 197      \e[1m-q      \e[22mDo not execute any commands, but exit 0 if the specified targets
 198              are up-to-date and 1, otherwise.
 199
 200      \e[1m-r      \e[22mDo not use the built-in rules specified in the system makefile.
 201
 202      \e[1m-s      \e[22mDo not echo any commands as they are executed.  Equivalent to
 203              specifying `\e[1m@\e[22m' before each command line in the makefile.
 204
 205      \e[1m-T \e[4m\e[22mtracefile\e[0m
 206              When used with the \e[1m-j \e[22mflag, append a trace record to \e[4mtracefile\e[0m
 207              for each job started and completed.
 208
 209      \e[1m-t      \e[22mRather than re-building a target as specified in the makefile,
 210              create it or update its modification time to make it appear up-
 211              to-date.
 212
 213      \e[1m-V \e[4m\e[22mvariable\e[0m
 214              Print the value of \e[4mvariable\e[24m.  Do not build any targets.  Multiple
 215              instances of this option may be specified; the variables will be
 216              printed one per line, with a blank line for each null or unde-
 217              fined variable.  The value printed is extracted from the global
 218              context after all makefiles have been read.  By default, the raw
 219              variable contents (which may include additional unexpanded vari-
 220              able references) are shown.  If \e[4mvariable\e[24m contains a `$' then the
 221              value will be recursively expanded to its complete resultant text
 222              before printing.  The expanded value will also be printed if
 223              \e[4m.MAKE.EXPAND_VARIABLES\e[24m is set to true and the \e[1m-dV \e[22moption has not
 224              been used to override it.  Note that loop-local and target-local
 225              variables, as well as values taken temporarily by global vari-
 226              ables during makefile processing, are not accessible via this
 227              option.  The \e[1m-dv \e[22mdebug mode can be used to see these at the cost
 228              of generating substantial extraneous output.
 229
 230      \e[1m-v \e[4m\e[22mvariable\e[0m
 231              Like \e[1m-V \e[22mbut the variable is always expanded to its complete
 232              value.
 233
 234      \e[1m-W      \e[22mTreat any warnings during makefile parsing as errors.
 235
 236      \e[1m-w      \e[22mPrint entering and leaving directory messages, pre and post pro-
 237              cessing.
 238
 239      \e[1m-X      \e[22mDon't export variables passed on the command line to the environ-
 240              ment individually.  Variables passed on the command line are
 241              still exported via the \e[4mMAKEFLAGS\e[24m environment variable.  This
 242              option may be useful on systems which have a small limit on the
 243              size of command arguments.
 244
 245      \e[4mvariable=value\e[0m
 246              Set the value of the variable \e[4mvariable\e[24m to \e[4mvalue\e[24m.  Normally, all
 247              values passed on the command line are also exported to sub-makes
 248              in the environment.  The \e[1m-X \e[22mflag disables this behavior.  Vari-
 249              able assignments should follow options for POSIX compatibility
 250              but no ordering is enforced.
 251
 252      There are seven different types of lines in a makefile: file dependency
 253      specifications, shell commands, variable assignments, include statements,
 254      conditional directives, for loops, and comments.
 255
 256      In general, lines may be continued from one line to the next by ending
 257      them with a backslash (`\').  The trailing newline character and initial
 258      whitespace on the following line are compressed into a single space.
 259
 260 \e[1mFILE DEPENDENCY SPECIFICATIONS\e[0m
 261      Dependency lines consist of one or more targets, an operator, and zero or
 262      more sources.  This creates a relationship where the targets ``depend''
 263      on the sources and are usually created from them.  The exact relationship
 264      between the target and the source is determined by the operator that sep-
 265      arates them.  The three operators are as follows:
 266
 267      \e[1m:     \e[22mA target is considered out-of-date if its modification time is less
 268            than those of any of its sources.  Sources for a target accumulate
 269            over dependency lines when this operator is used.  The target is
 270            removed if \e[1mbmake \e[22mis interrupted.
 271
 272      \e[1m!     \e[22mTargets are always re-created, but not until all sources have been
 273            examined and re-created as necessary.  Sources for a target accumu-
 274            late over dependency lines when this operator is used.  The target
 275            is removed if \e[1mbmake \e[22mis interrupted.
 276
 277      \e[1m::    \e[22mIf no sources are specified, the target is always re-created.  Oth-
 278            erwise, a target is considered out-of-date if any of its sources
 279            has been modified more recently than the target.  Sources for a
 280            target do not accumulate over dependency lines when this operator
 281            is used.  The target will not be removed if \e[1mbmake \e[22mis interrupted.
 282
 283      Targets and sources may contain the shell wildcard values `?', `*', `[]',
 284      and `{}'.  The values `?', `*', and `[]' may only be used as part of the
 285      final component of the target or source, and must be used to describe
 286      existing files.  The value `{}' need not necessarily be used to describe
 287      existing files.  Expansion is in directory order, not alphabetically as
 288      done in the shell.
 289
 290 \e[1mSHELL COMMANDS\e[0m
 291      Each target may have associated with it one or more lines of shell com-
 292      mands, normally used to create the target.  Each of the lines in this
 293      script \e[4mmust\e[24m be preceded by a tab.  (For historical reasons, spaces are
 294      not accepted.)  While targets can appear in many dependency lines if
 295      desired, by default only one of these rules may be followed by a creation
 296      script.  If the `\e[1m::\e[22m' operator is used, however, all rules may include
 297      scripts and the scripts are executed in the order found.
 298
 299      Each line is treated as a separate shell command, unless the end of line
 300      is escaped with a backslash (`\') in which case that line and the next
 301      are combined.  If the first characters of the command are any combination
 302      of `\e[1m@\e[22m', `\e[1m+\e[22m', or `\e[1m-\e[22m', the command is treated specially.  A `\e[1m@\e[22m' causes the
 303      command not to be echoed before it is executed.  A `\e[1m+\e[22m' causes the command
 304      to be executed even when \e[1m-n \e[22mis given.  This is similar to the effect of
 305      the .MAKE special source, except that the effect can be limited to a sin-
 306      gle line of a script.  A `\e[1m-\e[22m' in compatibility mode causes any non-zero
 307      exit status of the command line to be ignored.
 308
 309      When \e[1mbmake \e[22mis run in jobs mode with \e[1m-j \e[4m\e[22mmax_jobs\e[24m, the entire script for
 310      the target is fed to a single instance of the shell.  In compatibility
 311      (non-jobs) mode, each command is run in a separate process.  If the com-
 312      mand contains any shell meta characters (`#=|^(){};&<>*?[]:$`\\n') it
 313      will be passed to the shell; otherwise \e[1mbmake \e[22mwill attempt direct execu-
 314      tion.  If a line starts with `\e[1m-\e[22m' and the shell has ErrCtl enabled then
 315      failure of the command line will be ignored as in compatibility mode.
 316      Otherwise `\e[1m-\e[22m' affects the entire job; the script will stop at the first
 317      command line that fails, but the target will not be deemed to have
 318      failed.
 319
 320      Makefiles should be written so that the mode of \e[1mbmake \e[22moperation does not
 321      change their behavior.  For example, any command which needs to use
 322      ``cd'' or ``chdir'' without potentially changing the directory for subse-
 323      quent commands should be put in parentheses so it executes in a subshell.
 324      To force the use of one shell, escape the line breaks so as to make the
 325      whole script one command.  For example:
 326
 327            avoid-chdir-side-effects:
 328                    @echo Building $@ in `pwd`
 329                    @(cd ${.CURDIR} && ${MAKE} $@)
 330                    @echo Back in `pwd`
 331
 332            ensure-one-shell-regardless-of-mode:
 333                    @echo Building $@ in `pwd`; \
 334                    (cd ${.CURDIR} && ${MAKE} $@); \
 335                    echo Back in `pwd`
 336
 337      Since \e[1mbmake \e[22mwill chdir(2) to `\e[4m.OBJDIR\e[24m' before executing any targets, each
 338      child process starts with that as its current working directory.
 339
 340 \e[1mVARIABLE ASSIGNMENTS\e[0m
 341      Variables in make are much like variables in the shell, and, by tradi-
 342      tion, consist of all upper-case letters.
 343
 344    \e[1mVariable assignment modifiers\e[0m
 345      The five operators that can be used to assign values to variables are as
 346      follows:
 347
 348      \e[1m=       \e[22mAssign the value to the variable.  Any previous value is overrid-
 349              den.
 350
 351      \e[1m+=      \e[22mAppend the value to the current value of the variable.
 352
 353      \e[1m?=      \e[22mAssign the value to the variable if it is not already defined.
 354
 355      \e[1m:=      \e[22mAssign with expansion, i.e. expand the value before assigning it
 356              to the variable.  Normally, expansion is not done until the vari-
 357              able is referenced.  \e[4mNOTE\e[24m: References to undefined variables are
 358              \e[4mnot\e[24m expanded.  This can cause problems when variable modifiers
 359              are used.
 360
 361      \e[1m!=      \e[22mExpand the value and pass it to the shell for execution and
 362              assign the result to the variable.  Any newlines in the result
 363              are replaced with spaces.
 364
 365      Any white-space before the assigned \e[4mvalue\e[24m is removed; if the value is
 366      being appended, a single space is inserted between the previous contents
 367      of the variable and the appended value.
 368
 369      Variables are expanded by surrounding the variable name with either curly
 370      braces (`{}') or parentheses (`()') and preceding it with a dollar sign
 371      (`$').  If the variable name contains only a single letter, the surround-
 372      ing braces or parentheses are not required.  This shorter form is not
 373      recommended.
 374
 375      If the variable name contains a dollar, then the name itself is expanded
 376      first.  This allows almost arbitrary variable names, however names con-
 377      taining dollar, braces, parenthesis, or whitespace are really best
 378      avoided!
 379
 380      If the result of expanding a variable contains a dollar sign (`$') the
 381      string is expanded again.
 382
 383      Variable substitution occurs at three distinct times, depending on where
 384      the variable is being used.
 385
 386      1.   Variables in dependency lines are expanded as the line is read.
 387
 388      2.   Variables in shell commands are expanded when the shell command is
 389           executed.
 390
 391      3.   ``.for'' loop index variables are expanded on each loop iteration.
 392           Note that other variables are not expanded inside loops so the fol-
 393           lowing example code:
 394
 395
 396                 .for i in 1 2 3
 397                 a+=     ${i}
 398                 j=      ${i}
 399                 b+=     ${j}
 400                 .endfor
 401
 402                 all:
 403                         @echo ${a}
 404                         @echo ${b}
 405
 406           will print:
 407
 408                 1 2 3
 409                 3 3 3
 410
 411           Because while ${a} contains ``1 2 3'' after the loop is executed,
 412           ${b} contains ``${j} ${j} ${j}'' which expands to ``3 3 3'' since
 413           after the loop completes ${j} contains ``3''.
 414
 415    \e[1mVariable classes\e[0m
 416      The four different classes of variables (in order of increasing prece-
 417      dence) are:
 418
 419      Environment variables
 420              Variables defined as part of \e[1mbmake\e[22m's environment.
 421
 422      Global variables
 423              Variables defined in the makefile or in included makefiles.
 424
 425      Command line variables
 426              Variables defined as part of the command line.
 427
 428      Local variables
 429              Variables that are defined specific to a certain target.
 430
 431      Local variables are all built in and their values vary magically from
 432      target to target.  It is not currently possible to define new local vari-
 433      ables.  The seven local variables are as follows:
 434
 435            \e[4m.ALLSRC\e[24m   The list of all sources for this target; also known as
 436                      `\e[4m>\e[24m'.
 437
 438            \e[4m.ARCHIVE\e[24m  The name of the archive file; also known as `\e[4m!\e[24m'.
 439
 440            \e[4m.IMPSRC\e[24m   In suffix-transformation rules, the name/path of the
 441                      source from which the target is to be transformed (the
 442                      ``implied'' source); also known as `\e[4m<\e[24m'.  It is not
 443                      defined in explicit rules.
 444
 445            \e[4m.MEMBER\e[24m   The name of the archive member; also known as `\e[4m%\e[24m'.
 446
 447            \e[4m.OODATE\e[24m   The list of sources for this target that were deemed out-
 448                      of-date; also known as `\e[4m?\e[24m'.
 449
 450            \e[4m.PREFIX\e[24m   The file prefix of the target, containing only the file
 451                      portion, no suffix or preceding directory components;
 452                      also known as `\e[4m*\e[24m'.  The suffix must be one of the known
 453                      suffixes declared with \e[1m.SUFFIXES \e[22mor it will not be recog-
 454                      nized.
 455
 456            \e[4m.TARGET\e[24m   The name of the target; also known as `\e[4m@\e[24m'.  For compati-
 457                      bility with other makes this is an alias for \e[1m.ARCHIVE \e[22min
 458                      archive member rules.
 459
 460      The shorter forms (`\e[4m>\e[24m', `\e[4m!\e[24m', `\e[4m<\e[24m', `\e[4m%\e[24m', `\e[4m?\e[24m', `\e[4m*\e[24m', and `\e[4m@\e[24m') are permitted
 461      for backward compatibility with historical makefiles and legacy POSIX
 462      make and are not recommended.
 463
 464      Variants of these variables with the punctuation followed immediately by
 465      `D' or `F', e.g.  `\e[4m$(@D)\e[24m', are legacy forms equivalent to using the `:H'
 466      and `:T' modifiers.  These forms are accepted for compatibility with AT&T
 467      System V UNIX makefiles and POSIX but are not recommended.
 468
 469      Four of the local variables may be used in sources on dependency lines
 470      because they expand to the proper value for each target on the line.
 471      These variables are `\e[4m.TARGET\e[24m', `\e[4m.PREFIX\e[24m', `\e[4m.ARCHIVE\e[24m', and `\e[4m.MEMBER\e[24m'.
 472
 473    \e[1mAdditional built-in variables\e[0m
 474      In addition, \e[1mbmake \e[22msets or knows about the following variables:
 475
 476      \e[4m$\e[24m               A single dollar sign `$', i.e.  `$$' expands to a single
 477                      dollar sign.
 478
 479      \e[4m.ALLTARGETS\e[24m     The list of all targets encountered in the Makefile.  If
 480                      evaluated during Makefile parsing, lists only those tar-
 481                      gets encountered thus far.
 482
 483      \e[4m.CURDIR\e[24m         A path to the directory where \e[1mbmake \e[22mwas executed.  Refer
 484                      to the description of `PWD' for more details.
 485
 486      \e[4m.INCLUDEDFROMDIR\e[0m
 487                      The directory of the file this Makefile was included
 488                      from.
 489
 490      \e[4m.INCLUDEDFROMFILE\e[0m
 491                      The filename of the file this Makefile was included from.
 492
 493      MAKE            The name that \e[1mbmake \e[22mwas executed with (\e[4margv[0]\e[24m).  For
 494                      compatibility \e[1mbmake \e[22malso sets \e[4m.MAKE\e[24m with the same value.
 495                      The preferred variable to use is the environment variable
 496                      MAKE because it is more compatible with other versions of
 497                      \e[1mbmake \e[22mand cannot be confused with the special target with
 498                      the same name.
 499
 500      \e[4m.MAKE.DEPENDFILE\e[0m
 501                      Names the makefile (default `\e[4m.depend\e[24m') from which gener-
 502                      ated dependencies are read.
 503
 504      \e[4m.MAKE.EXPAND_VARIABLES\e[0m
 505                      A boolean that controls the default behavior of the \e[1m-V\e[0m
 506                      option.  If true, variable values printed with \e[1m-V \e[22mare
 507                      fully expanded; if false, the raw variable contents
 508                      (which may include additional unexpanded variable refer-
 509                      ences) are shown.
 510
 511      \e[4m.MAKE.EXPORTED\e[24m  The list of variables exported by \e[1mbmake\e[22m.
 512
 513      \e[4m.MAKE.JOBS\e[24m      The argument to the \e[1m-j \e[22moption.
 514
 515      \e[4m.MAKE.JOB.PREFIX\e[0m
 516                      If \e[1mbmake \e[22mis run with \e[4mj\e[24m then output for each target is
 517                      prefixed with a token `--- target ---' the first part of
 518                      which can be controlled via \e[4m.MAKE.JOB.PREFIX\e[24m.  If
 519                      \e[4m.MAKE.JOB.PREFIX\e[24m is empty, no token is printed.
 520                      For example:
 521                      .MAKE.JOB.PREFIX=${.newline}---${.MAKE:T}[${.MAKE.PID}]
 522                      would produce tokens like `---make[1234] target ---' mak-
 523                      ing it easier to track the degree of parallelism being
 524                      achieved.
 525
 526      MAKEFLAGS       The environment variable `MAKEFLAGS' may contain anything
 527                      that may be specified on \e[1mbmake\e[22m's command line.  Anything
 528                      specified on \e[1mbmake\e[22m's command line is appended to the
 529                      `MAKEFLAGS' variable which is then entered into the envi-
 530                      ronment for all programs which \e[1mbmake \e[22mexecutes.
 531
 532      \e[4m.MAKE.LEVEL\e[24m     The recursion depth of \e[1mbmake\e[22m.  The initial instance of
 533                      \e[1mbmake \e[22mwill be 0, and an incremented value is put into the
 534                      environment to be seen by the next generation.  This
 535                      allows tests like: .if ${.MAKE.LEVEL} == 0 to protect
 536                      things which should only be evaluated in the initial
 537                      instance of \e[1mbmake\e[22m.
 538
 539      \e[4m.MAKE.MAKEFILE_PREFERENCE\e[0m
 540                      The ordered list of makefile names (default `\e[4mmakefile\e[24m',
 541                      `\e[4mMakefile\e[24m') that \e[1mbmake \e[22mwill look for.
 542
 543      \e[4m.MAKE.MAKEFILES\e[0m
 544                      The list of makefiles read by \e[1mbmake\e[22m, which is useful for
 545                      tracking dependencies.  Each makefile is recorded only
 546                      once, regardless of the number of times read.
 547
 548      \e[4m.MAKE.MODE\e[24m      Processed after reading all makefiles.  Can affect the
 549                      mode that \e[1mbmake \e[22mruns in.  It can contain a number of key-
 550                      words:
 551
 552                      \e[4mcompat\e[24m               Like \e[1m-B\e[22m, puts \e[1mbmake \e[22minto "compat"
 553                                           mode.
 554
 555                      \e[4mmeta\e[24m                 Puts \e[1mbmake \e[22minto "meta" mode, where
 556                                           meta files are created for each tar-
 557                                           get to capture the command run, the
 558                                           output generated and if filemon(4)
 559                                           is available, the system calls which
 560                                           are of interest to \e[1mbmake\e[22m.  The cap-
 561                                           tured output can be very useful when
 562                                           diagnosing errors.
 563
 564                      \e[4mcurdirOk=\e[24m \e[4mbf\e[24m         Normally \e[1mbmake \e[22mwill not create .meta
 565                                           files in `\e[4m.CURDIR\e[24m'.  This can be
 566                                           overridden by setting \e[4mbf\e[24m to a value
 567                                           which represents True.
 568
 569                      \e[4mmissing-meta=\e[24m \e[4mbf\e[24m     If \e[4mbf\e[24m is True, then a missing .meta
 570                                           file makes the target out-of-date.
 571
 572                      \e[4mmissing-filemon=\e[24m \e[4mbf\e[24m  If \e[4mbf\e[24m is True, then missing filemon
 573                                           data makes the target out-of-date.
 574
 575                      \e[4mnofilemon\e[24m            Do not use filemon(4).
 576
 577                      \e[4menv\e[24m                  For debugging, it can be useful to
 578                                           include the environment in the .meta
 579                                           file.
 580
 581                      \e[4mverbose\e[24m              If in "meta" mode, print a clue
 582                                           about the target being built.  This
 583                                           is useful if the build is otherwise
 584                                           running silently.  The message
 585                                           printed the value of:
 586                                           \e[4m.MAKE.META.PREFIX\e[24m.
 587
 588                      \e[4mignore-cmd\e[24m           Some makefiles have commands which
 589                                           are simply not stable.  This keyword
 590                                           causes them to be ignored for deter-
 591                                           mining whether a target is out of
 592                                           date in "meta" mode.  See also
 593                                           \e[1m.NOMETA_CMP\e[22m.
 594
 595                      \e[4msilent=\e[24m \e[4mbf\e[24m           If \e[4mbf\e[24m is True, when a .meta file is
 596                                           created, mark the target \e[1m.SILENT\e[22m.
 597
 598      \e[4m.MAKE.META.BAILIWICK\e[0m
 599                      In "meta" mode, provides a list of prefixes which match
 600                      the directories controlled by \e[1mbmake\e[22m.  If a file that was
 601                      generated outside of \e[4m.OBJDIR\e[24m but within said bailiwick is
 602                      missing, the current target is considered out-of-date.
 603
 604      \e[4m.MAKE.META.CREATED\e[0m
 605                      In "meta" mode, this variable contains a list of all the
 606                      meta files updated.  If not empty, it can be used to
 607                      trigger processing of \e[4m.MAKE.META.FILES\e[24m.
 608
 609      \e[4m.MAKE.META.FILES\e[0m
 610                      In "meta" mode, this variable contains a list of all the
 611                      meta files used (updated or not).  This list can be used
 612                      to process the meta files to extract dependency informa-
 613                      tion.
 614
 615      \e[4m.MAKE.META.IGNORE_PATHS\e[0m
 616                      Provides a list of path prefixes that should be ignored;
 617                      because the contents are expected to change over time.
 618                      The default list includes: `\e[4m/dev\e[24m \e[4m/etc\e[24m \e[4m/proc\e[24m \e[4m/tmp\e[24m \e[4m/var/run\e[0m
 619                      \e[4m/var/tmp\e[24m'
 620
 621      \e[4m.MAKE.META.IGNORE_PATTERNS\e[0m
 622                      Provides a list of patterns to match against pathnames.
 623                      Ignore any that match.
 624
 625      \e[4m.MAKE.META.IGNORE_FILTER\e[0m
 626                      Provides a list of variable modifiers to apply to each
 627                      pathname.  Ignore if the expansion is an empty string.
 628
 629      \e[4m.MAKE.META.PREFIX\e[0m
 630                      Defines the message printed for each meta file updated in
 631                      "meta verbose" mode.  The default value is:
 632                            Building ${.TARGET:H:tA}/${.TARGET:T}
 633
 634      \e[4m.MAKEOVERRIDES\e[24m  This variable is used to record the names of variables
 635                      assigned to on the command line, so that they may be
 636                      exported as part of `MAKEFLAGS'.  This behavior can be
 637                      disabled by assigning an empty value to `\e[4m.MAKEOVERRIDES\e[24m'
 638                      within a makefile.  Extra variables can be exported from
 639                      a makefile by appending their names to `\e[4m.MAKEOVERRIDES\e[24m'.
 640                      `MAKEFLAGS' is re-exported whenever `\e[4m.MAKEOVERRIDES\e[24m' is
 641                      modified.
 642
 643      \e[4m.MAKE.PATH_FILEMON\e[0m
 644                      If \e[1mbmake \e[22mwas built with filemon(4) support, this is set
 645                      to the path of the device node.  This allows makefiles to
 646                      test for this support.
 647
 648      \e[4m.MAKE.PID\e[24m       The process-id of \e[1mbmake\e[22m.
 649
 650      \e[4m.MAKE.PPID\e[24m      The parent process-id of \e[1mbmake\e[22m.
 651
 652      \e[4m.MAKE.SAVE_DOLLARS\e[0m
 653                      value should be a boolean that controls whether `$$' are
 654                      preserved when doing `:=' assignments.  The default is
 655                      false, for backwards compatibility.  Set to true for com-
 656                      patability with other makes.  If set to false, `$$'
 657                      becomes `$' per normal evaluation rules.
 658
 659      \e[4mMAKE_PRINT_VAR_ON_ERROR\e[0m
 660                      When \e[1mbmake \e[22mstops due to an error, it sets `\e[4m.ERROR_TARGET\e[24m'
 661                      to the name of the target that failed, `\e[4m.ERROR_CMD\e[24m' to
 662                      the commands of the failed target, and in "meta" mode, it
 663                      also sets `\e[4m.ERROR_CWD\e[24m' to the getcwd(3), and
 664                      `\e[4m.ERROR_META_FILE\e[24m' to the path of the meta file (if any)
 665                      describing the failed target.  It then prints its name
 666                      and the value of `\e[4m.CURDIR\e[24m' as well as the value of any
 667                      variables named in `\e[4mMAKE_PRINT_VAR_ON_ERROR\e[24m'.
 668
 669      \e[4m.newline\e[24m        This variable is simply assigned a newline character as
 670                      its value.  This allows expansions using the \e[1m:@ \e[22mmodifier
 671                      to put a newline between iterations of the loop rather
 672                      than a space.  For example, the printing of
 673                      `\e[4mMAKE_PRINT_VAR_ON_ERROR\e[24m' could be done as
 674                      ${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}.
 675
 676      \e[4m.OBJDIR\e[24m         A path to the directory where the targets are built.  Its
 677                      value is determined by trying to chdir(2) to the follow-
 678                      ing directories in order and using the first match:
 679
 680                      1.   ${MAKEOBJDIRPREFIX}${.CURDIR}
 681
 682                           (Only if `MAKEOBJDIRPREFIX' is set in the environ-
 683                           ment or on the command line.)
 684
 685                      2.   ${MAKEOBJDIR}
 686
 687                           (Only if `MAKEOBJDIR' is set in the environment or
 688                           on the command line.)
 689
 690                      3.   ${.CURDIR}\e[4m/obj.\e[24m${MACHINE}
 691
 692                      4.   ${.CURDIR}\e[4m/obj\e[0m
 693
 694                      5.   \e[4m/usr/obj/\e[24m${.CURDIR}
 695
 696                      6.   ${.CURDIR}
 697
 698                      Variable expansion is performed on the value before it's
 699                      used, so expressions such as
 700                            ${.CURDIR:S,^/usr/src,/var/obj,}
 701                      may be used.  This is especially useful with
 702                      `MAKEOBJDIR'.
 703
 704                      `\e[4m.OBJDIR\e[24m' may be modified in the makefile via the special
 705                      target `\e[1m.OBJDIR\e[22m'.  In all cases, \e[1mbmake \e[22mwill chdir(2) to
 706                      the specified directory if it exists, and set `\e[4m.OBJDIR\e[24m'
 707                      and `PWD' to that directory before executing any targets.
 708
 709      \e[4m.PARSEDIR\e[24m       A path to the directory of the current `\e[4mMakefile\e[24m' being
 710                      parsed.
 711
 712      \e[4m.PARSEFILE\e[24m      The basename of the current `\e[4mMakefile\e[24m' being parsed.
 713                      This variable and `\e[4m.PARSEDIR\e[24m' are both set only while the
 714                      `\e[4mMakefiles\e[24m' are being parsed.  If you want to retain
 715                      their current values, assign them to a variable using
 716                      assignment with expansion: (`\e[1m:=\e[22m').
 717
 718      \e[4m.PATH\e[24m           A variable that represents the list of directories that
 719                      \e[1mbmake \e[22mwill search for files.  The search list should be
 720                      updated using the target `\e[4m.PATH\e[24m' rather than the vari-
 721                      able.
 722
 723      PWD             Alternate path to the current directory.  \e[1mbmake \e[22mnormally
 724                      sets `\e[4m.CURDIR\e[24m' to the canonical path given by getcwd(3).
 725                      However, if the environment variable `PWD' is set and
 726                      gives a path to the current directory, then \e[1mbmake \e[22msets
 727                      `\e[4m.CURDIR\e[24m' to the value of `PWD' instead.  This behavior
 728                      is disabled if `MAKEOBJDIRPREFIX' is set or `MAKEOBJDIR'
 729                      contains a variable transform.  `PWD' is set to the value
 730                      of `\e[4m.OBJDIR\e[24m' for all programs which \e[1mbmake \e[22mexecutes.
 731
 732      .TARGETS        The list of targets explicitly specified on the command
 733                      line, if any.
 734
 735      VPATH           Colon-separated (``:'') lists of directories that \e[1mbmake\e[0m
 736                      will search for files.  The variable is supported for
 737                      compatibility with old make programs only, use `\e[4m.PATH\e[24m'
 738                      instead.
 739
 740    \e[1mVariable modifiers\e[0m
 741      Variable expansion may be modified to select or modify each word of the
 742      variable (where a ``word'' is white-space delimited sequence of charac-
 743      ters).  The general format of a variable expansion is as follows:
 744
 745            ${variable[:modifier[:...]]}
 746
 747      Each modifier begins with a colon, which may be escaped with a backslash
 748      (`\').
 749
 750      A set of modifiers can be specified via a variable, as follows:
 751
 752            modifier_variable=modifier[:...]
 753            ${variable:${modifier_variable}[:...]}
 754
 755      In this case the first modifier in the modifier_variable does not start
 756      with a colon, since that must appear in the referencing variable.  If any
 757      of the modifiers in the modifier_variable contain a dollar sign (`$'),
 758      these must be doubled to avoid early expansion.
 759
 760      The supported modifiers are:
 761
 762      \e[1m:E   \e[22mReplaces each word in the variable with its suffix.
 763
 764      \e[1m:H   \e[22mReplaces each word in the variable with everything but the last com-
 765           ponent.
 766
 767      \e[1m:M\e[4m\e[22mpattern\e[0m
 768           Select only those words that match \e[4mpattern\e[24m.  The standard shell
 769           wildcard characters (`*', `?', and `[]') may be used.  The wildcard
 770           characters may be escaped with a backslash (`\').  As a consequence
 771           of the way values are split into words, matched, and then joined, a
 772           construct like
 773                 ${VAR:M*}
 774           will normalize the inter-word spacing, removing all leading and
 775           trailing space, and converting multiple consecutive spaces to single
 776           spaces.
 777
 778      \e[1m:N\e[4m\e[22mpattern\e[0m
 779           This is identical to `\e[1m:M\e[22m', but selects all words which do not match
 780           \e[4mpattern\e[24m.
 781
 782      \e[1m:O   \e[22mOrder every word in variable alphabetically.
 783
 784      \e[1m:Or  \e[22mOrder every word in variable in reverse alphabetical order.
 785
 786      \e[1m:Ox  \e[22mRandomize words in variable.  The results will be different each
 787           time you are referring to the modified variable; use the assignment
 788           with expansion (`\e[1m:=\e[22m') to prevent such behavior.  For example,
 789
 790                 LIST=                   uno due tre quattro
 791                 RANDOM_LIST=            ${LIST:Ox}
 792                 STATIC_RANDOM_LIST:=    ${LIST:Ox}
 793
 794                 all:
 795                         @echo "${RANDOM_LIST}"
 796                         @echo "${RANDOM_LIST}"
 797                         @echo "${STATIC_RANDOM_LIST}"
 798                         @echo "${STATIC_RANDOM_LIST}"
 799           may produce output similar to:
 800
 801                 quattro due tre uno
 802                 tre due quattro uno
 803                 due uno quattro tre
 804                 due uno quattro tre
 805
 806      \e[1m:Q   \e[22mQuotes every shell meta-character in the variable, so that it can be
 807           passed safely to the shell.
 808
 809      \e[1m:q   \e[22mQuotes every shell meta-character in the variable, and also doubles
 810           `$' characters so that it can be passed safely through recursive
 811           invocations of \e[1mbmake\e[22m.  This is equivalent to: `:S/\$/&&/g:Q'.
 812
 813      \e[1m:R   \e[22mReplaces each word in the variable with everything but its suffix.
 814
 815      \e[1m:range[=count]\e[0m
 816           The value is an integer sequence representing the words of the orig-
 817           inal value, or the supplied \e[4mcount\e[24m.
 818
 819      \e[1m:gmtime[=utc]\e[0m
 820           The value is a format string for strftime(3), using gmtime(3).  If a
 821           \e[4mutc\e[24m value is not provided or is 0, the current time is used.
 822
 823      \e[1m:hash\e[0m
 824           Compute a 32-bit hash of the value and encode it as hex digits.
 825
 826      \e[1m:localtime[=utc]\e[0m
 827           The value is a format string for strftime(3), using localtime(3).
 828           If a \e[4mutc\e[24m value is not provided or is 0, the current time is used.
 829
 830      \e[1m:tA  \e[22mAttempt to convert variable to an absolute path using realpath(3),
 831           if that fails, the value is unchanged.
 832
 833      \e[1m:tl  \e[22mConverts variable to lower-case letters.
 834
 835      \e[1m:ts\e[4m\e[22mc\e[0m
 836           Words in the variable are normally separated by a space on expan-
 837           sion.  This modifier sets the separator to the character \e[4mc\e[24m.  If \e[4mc\e[24m is
 838           omitted, then no separator is used.  The common escapes (including
 839           octal numeric codes), work as expected.
 840
 841      \e[1m:tu  \e[22mConverts variable to upper-case letters.
 842
 843      \e[1m:tW  \e[22mCauses the value to be treated as a single word (possibly containing
 844           embedded white space).  See also `\e[1m:[*]\e[22m'.
 845
 846      \e[1m:tw  \e[22mCauses the value to be treated as a sequence of words delimited by
 847           white space.  See also `\e[1m:[@]\e[22m'.
 848
 849      \e[1m:S\e[22m/\e[4mold_string\e[24m/\e[4mnew_string\e[24m/[\e[1m1gW\e[22m]
 850           Modify the first occurrence of \e[4mold_string\e[24m in the variable's value,
 851           replacing it with \e[4mnew_string\e[24m.  If a `g' is appended to the last
 852           slash of the pattern, all occurrences in each word are replaced.  If
 853           a `1' is appended to the last slash of the pattern, only the first
 854           word is affected.  If a `W' is appended to the last slash of the
 855           pattern, then the value is treated as a single word (possibly con-
 856           taining embedded white space).  If \e[4mold_string\e[24m begins with a caret
 857           (`^'), \e[4mold_string\e[24m is anchored at the beginning of each word.  If
 858           \e[4mold_string\e[24m ends with a dollar sign (`$'), it is anchored at the end
 859           of each word.  Inside \e[4mnew_string\e[24m, an ampersand (`&') is replaced by
 860           \e[4mold_string\e[24m (without any `^' or `$').  Any character may be used as a
 861           delimiter for the parts of the modifier string.  The anchoring,
 862           ampersand and delimiter characters may be escaped with a backslash
 863           (`\').
 864
 865           Variable expansion occurs in the normal fashion inside both
 866           \e[4mold_string\e[24m and \e[4mnew_string\e[24m with the single exception that a backslash
 867           is used to prevent the expansion of a dollar sign (`$'), not a pre-
 868           ceding dollar sign as is usual.
 869
 870      \e[1m:C\e[22m/\e[4mpattern\e[24m/\e[4mreplacement\e[24m/[\e[1m1gW\e[22m]
 871           The \e[1m:C \e[22mmodifier is just like the \e[1m:S \e[22mmodifier except that the old and
 872           new strings, instead of being simple strings, are an extended regu-
 873           lar expression (see regex(3)) string \e[4mpattern\e[24m and an ed(1)-style
 874           string \e[4mreplacement\e[24m.  Normally, the first occurrence of the pattern
 875           \e[4mpattern\e[24m in each word of the value is substituted with \e[4mreplacement\e[24m.
 876           The `1' modifier causes the substitution to apply to at most one
 877           word; the `g' modifier causes the substitution to apply to as many
 878           instances of the search pattern \e[4mpattern\e[24m as occur in the word or
 879           words it is found in; the `W' modifier causes the value to be
 880           treated as a single word (possibly containing embedded white space).
 881           Note that `1' and `g' are orthogonal; the former specifies whether
 882           multiple words are potentially affected, the latter whether multiple
 883           substitutions can potentially occur within each affected word.
 884
 885           As for the \e[1m:S \e[22mmodifier, the \e[4mpattern\e[24m and \e[4mreplacement\e[24m are subjected to
 886           variable expansion before being parsed as regular expressions.
 887
 888      \e[1m:T   \e[22mReplaces each word in the variable with its last component.
 889
 890      \e[1m:u   \e[22mRemove adjacent duplicate words (like uniq(1)).
 891
 892      \e[1m:?\e[4m\e[22mtrue_string\e[24m\e[1m:\e[4m\e[22mfalse_string\e[0m
 893           If the variable name (not its value), when parsed as a .if condi-
 894           tional expression, evaluates to true, return as its value the
 895           \e[4mtrue_string\e[24m, otherwise return the \e[4mfalse_string\e[24m.  Since the variable
 896           name is used as the expression, :? must be the first modifier after
 897           the variable name itself - which will, of course, usually contain
 898           variable expansions.  A common error is trying to use expressions
 899           like
 900                 ${NUMBERS:M42:?match:no}
 901           which actually tests defined(NUMBERS), to determine is any words
 902           match "42" you need to use something like:
 903                 ${"${NUMBERS:M42}" != "":?match:no}.
 904
 905      \e[4m:old_string=new_string\e[0m
 906           This is the AT&T System V UNIX style variable substitution.  It must
 907           be the last modifier specified.  If \e[4mold_string\e[24m or \e[4mnew_string\e[24m do not
 908           contain the pattern matching character \e[4m%\e[24m then it is assumed that
 909           they are anchored at the end of each word, so only suffixes or
 910           entire words may be replaced.  Otherwise \e[4m%\e[24m is the substring of
 911           \e[4mold_string\e[24m to be replaced in \e[4mnew_string\e[24m.  If only \e[4mold_string\e[24m con-
 912           tains the pattern matching character \e[4m%\e[24m, and \e[4mold_string\e[24m matches, then
 913           the result is the \e[4mnew_string\e[24m.  If only the \e[4mnew_string\e[24m contains the
 914           pattern matching character \e[4m%\e[24m, then it is not treated specially and
 915           it is printed as a literal \e[4m%\e[24m on match.  If there is more than one
 916           pattern matching character (\e[4m%\e[24m) in either the \e[4mnew_string\e[24m or
 917           \e[4mold_string\e[24m, only the first instance is treated specially (as the
 918           pattern character); all subsequent instances are treated as regular
 919           characters
 920
 921           Variable expansion occurs in the normal fashion inside both
 922           \e[4mold_string\e[24m and \e[4mnew_string\e[24m with the single exception that a backslash
 923           is used to prevent the expansion of a dollar sign (`$'), not a pre-
 924           ceding dollar sign as is usual.
 925
 926      \e[1m:@\e[4m\e[22mtemp\e[24m\e[1m@\e[4m\e[22mstring\e[24m\e[1m@\e[0m
 927           This is the loop expansion mechanism from the OSF Development Envi-
 928           ronment (ODE) make.  Unlike \e[1m.for \e[22mloops expansion occurs at the time
 929           of reference.  Assign \e[4mtemp\e[24m to each word in the variable and evaluate
 930           \e[4mstring\e[24m.  The ODE convention is that \e[4mtemp\e[24m should start and end with a
 931           period.  For example.
 932                 ${LINKS:@.LINK.@${LN} ${TARGET} ${.LINK.}@}
 933
 934           However a single character variable is often more readable:
 935                 ${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}
 936
 937      \e[1m:_[=var]\e[0m
 938           Save the current variable value in `$_' or the named \e[4mvar\e[24m for later
 939           reference.  Example usage:
 940
 941                 M_cmpv.units = 1 1000 1000000
 942                 M_cmpv = S,., ,g:_:range:@i@+ $${_:[-$$i]} \
 943                 \* $${M_cmpv.units:[$$i]}@:S,^,expr 0 ,1:sh
 944
 945                 .if ${VERSION:${M_cmpv}} < ${3.1.12:L:${M_cmpv}}
 946
 947           Here `$_' is used to save the result of the `:S' modifier which is
 948           later referenced using the index values from `:range'.
 949
 950      \e[1m:U\e[4m\e[22mnewval\e[0m
 951           If the variable is undefined \e[4mnewval\e[24m is the value.  If the variable
 952           is defined, the existing value is returned.  This is another ODE
 953           make feature.  It is handy for setting per-target CFLAGS for
 954           instance:
 955                 ${_${.TARGET:T}_CFLAGS:U${DEF_CFLAGS}}
 956           If a value is only required if the variable is undefined, use:
 957                 ${VAR:D:Unewval}
 958
 959      \e[1m:D\e[4m\e[22mnewval\e[0m
 960           If the variable is defined \e[4mnewval\e[24m is the value.
 961
 962      \e[1m:L   \e[22mThe name of the variable is the value.
 963
 964      \e[1m:P   \e[22mThe path of the node which has the same name as the variable is the
 965           value.  If no such node exists or its path is null, then the name of
 966           the variable is used.  In order for this modifier to work, the name
 967           (node) must at least have appeared on the rhs of a dependency.
 968
 969      \e[1m:!\e[4m\e[22mcmd\e[24m\e[1m!\e[0m
 970           The output of running \e[4mcmd\e[24m is the value.
 971
 972      \e[1m:sh  \e[22mIf the variable is non-empty it is run as a command and the output
 973           becomes the new value.
 974
 975      \e[1m::=\e[4m\e[22mstr\e[0m
 976           The variable is assigned the value \e[4mstr\e[24m after substitution.  This
 977           modifier and its variations are useful in obscure situations such as
 978           wanting to set a variable when shell commands are being parsed.
 979           These assignment modifiers always expand to nothing, so if appearing
 980           in a rule line by themselves should be preceded with something to
 981           keep \e[1mbmake \e[22mhappy.
 982
 983           The `\e[1m::\e[22m' helps avoid false matches with the AT&T System V UNIX style
 984           \e[1m:= \e[22mmodifier and since substitution always occurs the \e[1m::= \e[22mform is
 985           vaguely appropriate.
 986
 987      \e[1m::?=\e[4m\e[22mstr\e[0m
 988           As for \e[1m::= \e[22mbut only if the variable does not already have a value.
 989
 990      \e[1m::+=\e[4m\e[22mstr\e[0m
 991           Append \e[4mstr\e[24m to the variable.
 992
 993      \e[1m::!=\e[4m\e[22mcmd\e[0m
 994           Assign the output of \e[4mcmd\e[24m to the variable.
 995
 996      \e[1m:[\e[4m\e[22mrange\e[24m\e[1m]\e[0m
 997           Selects one or more words from the value, or performs other opera-
 998           tions related to the way in which the value is divided into words.
 999
1000           Ordinarily, a value is treated as a sequence of words delimited by
1001           white space.  Some modifiers suppress this behavior, causing a value
1002           to be treated as a single word (possibly containing embedded white
1003           space).  An empty value, or a value that consists entirely of white-
1004           space, is treated as a single word.  For the purposes of the `\e[1m:[]\e[22m'
1005           modifier, the words are indexed both forwards using positive inte-
1006           gers (where index 1 represents the first word), and backwards using
1007           negative integers (where index -1 represents the last word).
1008
1009           The \e[4mrange\e[24m is subjected to variable expansion, and the expanded
1010           result is then interpreted as follows:
1011
1012           \e[4mindex\e[24m  Selects a single word from the value.
1013
1014           \e[4mstart\e[24m\e[1m..\e[4m\e[22mend\e[0m
1015                  Selects all words from \e[4mstart\e[24m to \e[4mend\e[24m, inclusive.  For example,
1016                  `\e[1m:[2..-1]\e[22m' selects all words from the second word to the last
1017                  word.  If \e[4mstart\e[24m is greater than \e[4mend\e[24m, then the words are out-
1018                  put in reverse order.  For example, `\e[1m:[-1..1]\e[22m' selects all
1019                  the words from last to first.  If the list is already
1020                  ordered, then this effectively reverses the list, but it is
1021                  more efficient to use `\e[1m:Or\e[22m' instead of `\e[1m:O:[-1..1]\e[22m'.
1022
1023           \e[1m*      \e[22mCauses subsequent modifiers to treat the value as a single
1024                  word (possibly containing embedded white space).  Analogous
1025                  to the effect of "$*" in Bourne shell.
1026
1027           0      Means the same as `\e[1m:[*]\e[22m'.
1028
1029           \e[1m@      \e[22mCauses subsequent modifiers to treat the value as a sequence
1030                  of words delimited by white space.  Analogous to the effect
1031                  of "$@" in Bourne shell.
1032
1033           \e[1m#      \e[22mReturns the number of words in the value.
1034
1035 \e[1mINCLUDE STATEMENTS, CONDITIONALS AND FOR LOOPS\e[0m
1036      Makefile inclusion, conditional structures and for loops  reminiscent of
1037      the C programming language are provided in \e[1mbmake\e[22m.  All such structures
1038      are identified by a line beginning with a single dot (`.') character.
1039      Files are included with either \e[1m.include <\e[4m\e[22mfile\e[24m\e[1m> \e[22mor \e[1m.include "\e[4m\e[22mfile\e[24m\e[1m"\e[22m.  Vari-
1040      ables between the angle brackets or double quotes are expanded to form
1041      the file name.  If angle brackets are used, the included makefile is
1042      expected to be in the system makefile directory.  If double quotes are
1043      used, the including makefile's directory and any directories specified
1044      using the \e[1m-I \e[22moption are searched before the system makefile directory.
1045      For compatibility with other versions of \e[1mbmake \e[22m`include file ...' is also
1046      accepted.
1047
1048      If the include statement is written as \e[1m.-include \e[22mor as \e[1m.sinclude \e[22mthen
1049      errors locating and/or opening include files are ignored.
1050
1051      If the include statement is written as \e[1m.dinclude \e[22mnot only are errors
1052      locating and/or opening include files ignored, but stale dependencies
1053      within the included file will be ignored just like \e[4m.MAKE.DEPENDFILE\e[24m.
1054
1055      Conditional expressions are also preceded by a single dot as the first
1056      character of a line.  The possible conditionals are as follows:
1057
1058      \e[1m.error \e[4m\e[22mmessage\e[0m
1059              The message is printed along with the name of the makefile and
1060              line number, then \e[1mbmake \e[22mwill exit.
1061
1062      \e[1m.export \e[4m\e[22mvariable\e[24m \e[4m...\e[0m
1063              Export the specified global variable.  If no variable list is
1064              provided, all globals are exported except for internal variables
1065              (those that start with `.').  This is not affected by the \e[1m-X\e[0m
1066              flag, so should be used with caution.  For compatibility with
1067              other \e[1mbmake \e[22mprograms `export variable=value' is also accepted.
1068
1069              Appending a variable name to \e[4m.MAKE.EXPORTED\e[24m is equivalent to
1070              exporting a variable.
1071
1072      \e[1m.export-env \e[4m\e[22mvariable\e[24m \e[4m...\e[0m
1073              The same as `.export', except that the variable is not appended
1074              to \e[4m.MAKE.EXPORTED\e[24m.  This allows exporting a value to the environ-
1075              ment which is different from that used by \e[1mbmake \e[22minternally.
1076
1077      \e[1m.export-literal \e[4m\e[22mvariable\e[24m \e[4m...\e[0m
1078              The same as `.export-env', except that variables in the value are
1079              not expanded.
1080
1081      \e[1m.info \e[4m\e[22mmessage\e[0m
1082              The message is printed along with the name of the makefile and
1083              line number.
1084
1085      \e[1m.undef \e[4m\e[22mvariable\e[0m
1086              Un-define the specified global variable.  Only global variables
1087              may be un-defined.
1088
1089      \e[1m.unexport \e[4m\e[22mvariable\e[24m \e[4m...\e[0m
1090              The opposite of `.export'.  The specified global \e[4mvariable\e[24m will be
1091              removed from \e[4m.MAKE.EXPORTED\e[24m.  If no variable list is provided,
1092              all globals are unexported, and \e[4m.MAKE.EXPORTED\e[24m deleted.
1093
1094      \e[1m.unexport-env\e[0m
1095              Unexport all globals previously exported and clear the environ-
1096              ment inherited from the parent.  This operation will cause a mem-
1097              ory leak of the original environment, so should be used spar-
1098              ingly.  Testing for \e[4m.MAKE.LEVEL\e[24m being 0, would make sense.  Also
1099              note that any variables which originated in the parent environ-
1100              ment should be explicitly preserved if desired.  For example:
1101
1102                    .if ${.MAKE.LEVEL} == 0
1103                    PATH := ${PATH}
1104                    .unexport-env
1105                    .export PATH
1106                    .endif
1107
1108              Would result in an environment containing only `PATH', which is
1109              the minimal useful environment.  Actually `.MAKE.LEVEL' will also
1110              be pushed into the new environment.
1111
1112      \e[1m.warning \e[4m\e[22mmessage\e[0m
1113              The message prefixed by `\e[4mwarning:\e[24m' is printed along with the name
1114              of the makefile and line number.
1115
1116      \e[1m.if \e[22m[!]\e[4mexpression\e[24m [\e[4moperator\e[24m \e[4mexpression\e[24m \e[4m...\e[24m]
1117              Test the value of an expression.
1118
1119      \e[1m.ifdef \e[22m[!]\e[4mvariable\e[24m [\e[4moperator\e[24m \e[4mvariable\e[24m \e[4m...\e[24m]
1120              Test the value of a variable.
1121
1122      \e[1m.ifndef \e[22m[!]\e[4mvariable\e[24m [\e[4moperator\e[24m \e[4mvariable\e[24m \e[4m...\e[24m]
1123              Test the value of a variable.
1124
1125      \e[1m.ifmake \e[22m[!]\e[4mtarget\e[24m [\e[4moperator\e[24m \e[4mtarget\e[24m \e[4m...\e[24m]
1126              Test the target being built.
1127
1128      \e[1m.ifnmake \e[22m[!] \e[4mtarget\e[24m [\e[4moperator\e[24m \e[4mtarget\e[24m \e[4m...\e[24m]
1129              Test the target being built.
1130
1131      \e[1m.else   \e[22mReverse the sense of the last conditional.
1132
1133      \e[1m.elif \e[22m[!] \e[4mexpression\e[24m [\e[4moperator\e[24m \e[4mexpression\e[24m \e[4m...\e[24m]
1134              A combination of `\e[1m.else\e[22m' followed by `\e[1m.if\e[22m'.
1135
1136      \e[1m.elifdef \e[22m[!]\e[4mvariable\e[24m [\e[4moperator\e[24m \e[4mvariable\e[24m \e[4m...\e[24m]
1137              A combination of `\e[1m.else\e[22m' followed by `\e[1m.ifdef\e[22m'.
1138
1139      \e[1m.elifndef \e[22m[!]\e[4mvariable\e[24m [\e[4moperator\e[24m \e[4mvariable\e[24m \e[4m...\e[24m]
1140              A combination of `\e[1m.else\e[22m' followed by `\e[1m.ifndef\e[22m'.
1141
1142      \e[1m.elifmake \e[22m[!]\e[4mtarget\e[24m [\e[4moperator\e[24m \e[4mtarget\e[24m \e[4m...\e[24m]
1143              A combination of `\e[1m.else\e[22m' followed by `\e[1m.ifmake\e[22m'.
1144
1145      \e[1m.elifnmake \e[22m[!]\e[4mtarget\e[24m [\e[4moperator\e[24m \e[4mtarget\e[24m \e[4m...\e[24m]
1146              A combination of `\e[1m.else\e[22m' followed by `\e[1m.ifnmake\e[22m'.
1147
1148      \e[1m.endif  \e[22mEnd the body of the conditional.
1149
1150      The \e[4moperator\e[24m may be any one of the following:
1151
1152      \e[1m||     \e[22mLogical OR.
1153
1154      \e[1m&&     \e[22mLogical AND; of higher precedence than ``||''.
1155
1156      As in C, \e[1mbmake \e[22mwill only evaluate a conditional as far as is necessary to
1157      determine its value.  Parentheses may be used to change the order of
1158      evaluation.  The boolean operator `\e[1m!\e[22m' may be used to logically negate an
1159      entire conditional.  It is of higher precedence than `\e[1m&&\e[22m'.
1160
1161      The value of \e[4mexpression\e[24m may be any of the following:
1162
1163      \e[1mdefined  \e[22mTakes a variable name as an argument and evaluates to true if
1164               the variable has been defined.
1165
1166      \e[1mmake     \e[22mTakes a target name as an argument and evaluates to true if the
1167               target was specified as part of \e[1mbmake\e[22m's command line or was
1168               declared the default target (either implicitly or explicitly,
1169               see \e[4m.MAIN\e[24m) before the line containing the conditional.
1170
1171      \e[1mempty    \e[22mTakes a variable, with possible modifiers, and evaluates to true
1172               if the expansion of the variable would result in an empty
1173               string.
1174
1175      \e[1mexists   \e[22mTakes a file name as an argument and evaluates to true if the
1176               file exists.  The file is searched for on the system search path
1177               (see \e[4m.PATH\e[24m).
1178
1179      \e[1mtarget   \e[22mTakes a target name as an argument and evaluates to true if the
1180               target has been defined.
1181
1182      \e[1mcommands\e[0m
1183               Takes a target name as an argument and evaluates to true if the
1184               target has been defined and has commands associated with it.
1185
1186      \e[4mExpression\e[24m may also be an arithmetic or string comparison.  Variable
1187      expansion is performed on both sides of the comparison, after which the
1188      integral values are compared.  A value is interpreted as hexadecimal if
1189      it is preceded by 0x, otherwise it is decimal; octal numbers are not sup-
1190      ported.  The standard C relational operators are all supported.  If after
1191      variable expansion, either the left or right hand side of a `\e[1m==\e[22m' or `\e[1m!=\e[22m'
1192      operator is not an integral value, then string comparison is performed
1193      between the expanded variables.  If no relational operator is given, it
1194      is assumed that the expanded variable is being compared against 0 or an
1195      empty string in the case of a string comparison.
1196
1197      When \e[1mbmake \e[22mis evaluating one of these conditional expressions, and it
1198      encounters a (white-space separated) word it doesn't recognize, either
1199      the ``make'' or ``defined'' expression is applied to it, depending on the
1200      form of the conditional.  If the form is `\e[1m.ifdef\e[22m', `\e[1m.ifndef\e[22m', or `\e[1m.if\e[22m'
1201      the ``defined'' expression is applied.  Similarly, if the form is
1202      `\e[1m.ifmake\e[22m' or `\e[1m.ifnmake\e[22m', the ``make'' expression is applied.
1203
1204      If the conditional evaluates to true the parsing of the makefile contin-
1205      ues as before.  If it evaluates to false, the following lines are
1206      skipped.  In both cases this continues until a `\e[1m.else\e[22m' or `\e[1m.endif\e[22m' is
1207      found.
1208
1209      For loops are typically used to apply a set of rules to a list of files.
1210      The syntax of a for loop is:
1211
1212      \e[1m.for \e[4m\e[22mvariable\e[24m [\e[4mvariable\e[24m \e[4m...\e[24m] \e[1min \e[4m\e[22mexpression\e[0m
1213      <make-rules>
1214      \e[1m.endfor\e[0m
1215
1216      After the for \e[1mexpression \e[22mis evaluated, it is split into words.  On each
1217      iteration of the loop, one word is taken and assigned to each \e[1mvariable\e[22m,
1218      in order, and these \e[1mvariables \e[22mare substituted into the \e[1mmake-rules \e[22minside
1219      the body of the for loop.  The number of words must come out even; that
1220      is, if there are three iteration variables, the number of words provided
1221      must be a multiple of three.
1222
1223 \e[1mCOMMENTS\e[0m
1224      Comments begin with a hash (`#') character, anywhere but in a shell com-
1225      mand line, and continue to the end of an unescaped new line.
1226
1227 \e[1mSPECIAL SOURCES (ATTRIBUTES)\e[0m
1228      \e[1m.EXEC     \e[22mTarget is never out of date, but always execute commands any-
1229                way.
1230
1231      \e[1m.IGNORE   \e[22mIgnore any errors from the commands associated with this tar-
1232                get, exactly as if they all were preceded by a dash (`-').
1233
1234      \e[1m.MADE     \e[22mMark all sources of this target as being up-to-date.
1235
1236      \e[1m.MAKE     \e[22mExecute the commands associated with this target even if the \e[1m-n\e[0m
1237                or \e[1m-t \e[22moptions were specified.  Normally used to mark recursive
1238                \e[1mbmake\e[22ms.
1239
1240      \e[1m.META     \e[22mCreate a meta file for the target, even if it is flagged as
1241                \e[1m.PHONY\e[22m, \e[1m.MAKE\e[22m, or \e[1m.SPECIAL\e[22m.  Usage in conjunction with \e[1m.MAKE \e[22mis
1242                the most likely case.  In "meta" mode, the target is out-of-
1243                date if the meta file is missing.
1244
1245      \e[1m.NOMETA   \e[22mDo not create a meta file for the target.  Meta files are also
1246                not created for \e[1m.PHONY\e[22m, \e[1m.MAKE\e[22m, or \e[1m.SPECIAL \e[22mtargets.
1247
1248      \e[1m.NOMETA_CMP\e[0m
1249                Ignore differences in commands when deciding if target is out
1250                of date.  This is useful if the command contains a value which
1251                always changes.  If the number of commands change, though, the
1252                target will still be out of date.  The same effect applies to
1253                any command line that uses the variable \e[4m.OODATE\e[24m, which can be
1254                used for that purpose even when not otherwise needed or
1255                desired:
1256
1257
1258                      skip-compare-for-some:
1259                              @echo this will be compared
1260                              @echo this will not ${.OODATE:M.NOMETA_CMP}
1261                              @echo this will also be compared
1262
1263                The \e[1m:M \e[22mpattern suppresses any expansion of the unwanted vari-
1264                able.
1265
1266      \e[1m.NOPATH   \e[22mDo not search for the target in the directories specified by
1267                \e[1m.PATH\e[22m.
1268
1269      \e[1m.NOTMAIN  \e[22mNormally \e[1mbmake \e[22mselects the first target it encounters as the
1270                default target to be built if no target was specified.  This
1271                source prevents this target from being selected.
1272
1273      \e[1m.OPTIONAL\e[0m
1274                If a target is marked with this attribute and \e[1mbmake \e[22mcan't fig-
1275                ure out how to create it, it will ignore this fact and assume
1276                the file isn't needed or already exists.
1277
1278      \e[1m.PHONY    \e[22mThe target does not correspond to an actual file; it is always
1279                considered to be out of date, and will not be created with the
1280                \e[1m-t \e[22moption.  Suffix-transformation rules are not applied to
1281                \e[1m.PHONY \e[22mtargets.
1282
1283      \e[1m.PRECIOUS\e[0m
1284                When \e[1mbmake \e[22mis interrupted, it normally removes any partially
1285                made targets.  This source prevents the target from being
1286                removed.
1287
1288      \e[1m.RECURSIVE\e[0m
1289                Synonym for \e[1m.MAKE\e[22m.
1290
1291      \e[1m.SILENT   \e[22mDo not echo any of the commands associated with this target,
1292                exactly as if they all were preceded by an at sign (`@').
1293
1294      \e[1m.USE      \e[22mTurn the target into \e[1mbmake\e[22m's version of a macro.  When the tar-
1295                get is used as a source for another target, the other target
1296                acquires the commands, sources, and attributes (except for
1297                \e[1m.USE\e[22m) of the source.  If the target already has commands, the
1298                \e[1m.USE \e[22mtarget's commands are appended to them.
1299
1300      \e[1m.USEBEFORE\e[0m
1301                Exactly like \e[1m.USE\e[22m, but prepend the \e[1m.USEBEFORE \e[22mtarget commands
1302                to the target.
1303
1304      \e[1m.WAIT     \e[22mIf \e[1m.WAIT \e[22mappears in a dependency line, the sources that precede
1305                it are made before the sources that succeed it in the line.
1306                Since the dependents of files are not made until the file
1307                itself could be made, this also stops the dependents being
1308                built unless they are needed for another branch of the depen-
1309                dency tree.  So given:
1310
1311                x: a .WAIT b
1312                        echo x
1313                a:
1314                        echo a
1315                b: b1
1316                        echo b
1317                b1:
1318                        echo b1
1319
1320                the output is always `a', `b1', `b', `x'.
1321                The ordering imposed by \e[1m.WAIT \e[22mis only relevant for parallel
1322                makes.
1323
1324 \e[1mSPECIAL TARGETS\e[0m
1325      Special targets may not be included with other targets, i.e. they must be
1326      the only target specified.
1327
1328      \e[1m.BEGIN   \e[22mAny command lines attached to this target are executed before
1329               anything else is done.
1330
1331      \e[1m.DEFAULT\e[0m
1332               This is sort of a \e[1m.USE \e[22mrule for any target (that was used only
1333               as a source) that \e[1mbmake \e[22mcan't figure out any other way to cre-
1334               ate.  Only the shell script is used.  The \e[1m.IMPSRC \e[22mvariable of a
1335               target that inherits \e[1m.DEFAULT\e[22m's commands is set to the target's
1336               own name.
1337
1338      \e[1m.DELETE_ON_ERROR\e[0m
1339               If this target is present in the makefile, it globally causes
1340               make to delete targets whose commands fail.  (By default, only
1341               targets whose commands are interrupted during execution are
1342               deleted.  This is the historical behavior.)  This setting can be
1343               used to help prevent half-finished or malformed targets from
1344               being left around and corrupting future rebuilds.
1345
1346      \e[1m.END     \e[22mAny command lines attached to this target are executed after
1347               everything else is done.
1348
1349      \e[1m.ERROR   \e[22mAny command lines attached to this target are executed when
1350               another target fails.  The \e[1m.ERROR_TARGET \e[22mvariable is set to the
1351               target that failed.  See also \e[1mMAKE_PRINT_VAR_ON_ERROR\e[22m.
1352
1353      \e[1m.IGNORE  \e[22mMark each of the sources with the \e[1m.IGNORE \e[22mattribute.  If no
1354               sources are specified, this is the equivalent of specifying the
1355               \e[1m-i \e[22moption.
1356
1357      \e[1m.INTERRUPT\e[0m
1358               If \e[1mbmake \e[22mis interrupted, the commands for this target will be
1359               executed.
1360
1361      \e[1m.MAIN    \e[22mIf no target is specified when \e[1mbmake \e[22mis invoked, this target
1362               will be built.
1363
1364      \e[1m.MAKEFLAGS\e[0m
1365               This target provides a way to specify flags for \e[1mbmake \e[22mwhen the
1366               makefile is used.  The flags are as if typed to the shell,
1367               though the \e[1m-f \e[22moption will have no effect.
1368
1369      \e[1m.NOPATH  \e[22mApply the \e[1m.NOPATH \e[22mattribute to any specified sources.
1370
1371      \e[1m.NOTPARALLEL\e[0m
1372               Disable parallel mode.
1373
1374      \e[1m.NO_PARALLEL\e[0m
1375               Synonym for \e[1m.NOTPARALLEL\e[22m, for compatibility with other pmake
1376               variants.
1377
1378      \e[1m.OBJDIR  \e[22mThe source is a new value for `\e[4m.OBJDIR\e[24m'.  If it exists, \e[1mbmake\e[0m
1379               will chdir(2) to it and update the value of `\e[4m.OBJDIR\e[24m'.
1380
1381      \e[1m.ORDER   \e[22mThe named targets are made in sequence.  This ordering does not
1382               add targets to the list of targets to be made.  Since the depen-
1383               dents of a target do not get built until the target itself could
1384               be built, unless `a' is built by another part of the dependency
1385               graph, the following is a dependency loop:
1386
1387               .ORDER: b a
1388               b: a
1389
1390               The ordering imposed by \e[1m.ORDER \e[22mis only relevant for parallel
1391               makes.
1392
1393      \e[1m.PATH    \e[22mThe sources are directories which are to be searched for files
1394               not found in the current directory.  If no sources are speci-
1395               fied, any previously specified directories are deleted.  If the
1396               source is the special \e[1m.DOTLAST \e[22mtarget, then the current working
1397               directory is searched last.
1398
1399      \e[1m.PATH.\e[4m\e[22msuffix\e[0m
1400               Like \e[1m.PATH \e[22mbut applies only to files with a particular suffix.
1401               The suffix must have been previously declared with \e[1m.SUFFIXES\e[22m.
1402
1403      \e[1m.PHONY   \e[22mApply the \e[1m.PHONY \e[22mattribute to any specified sources.
1404
1405      \e[1m.PRECIOUS\e[0m
1406               Apply the \e[1m.PRECIOUS \e[22mattribute to any specified sources.  If no
1407               sources are specified, the \e[1m.PRECIOUS \e[22mattribute is applied to
1408               every target in the file.
1409
1410      \e[1m.SHELL   \e[22mSets the shell that \e[1mbmake \e[22mwill use to execute commands.  The
1411               sources are a set of \e[4mfield=value\e[24m pairs.
1412
1413               \e[4mname\e[24m        This is the minimal specification, used to select
1414                           one of the built-in shell specs; \e[4msh\e[24m, \e[4mksh\e[24m, and \e[4mcsh\e[24m.
1415
1416               \e[4mpath\e[24m        Specifies the path to the shell.
1417
1418               \e[4mhasErrCtl\e[24m   Indicates whether the shell supports exit on error.
1419
1420               \e[4mcheck\e[24m       The command to turn on error checking.
1421
1422               \e[4mignore\e[24m      The command to disable error checking.
1423
1424               \e[4mecho\e[24m        The command to turn on echoing of commands executed.
1425
1426               \e[4mquiet\e[24m       The command to turn off echoing of commands exe-
1427                           cuted.
1428
1429               \e[4mfilter\e[24m      The output to filter after issuing the \e[4mquiet\e[24m com-
1430                           mand.  It is typically identical to \e[4mquiet\e[24m.
1431
1432               \e[4merrFlag\e[24m     The flag to pass the shell to enable error checking.
1433
1434               \e[4mechoFlag\e[24m    The flag to pass the shell to enable command echo-
1435                           ing.
1436
1437               \e[4mnewline\e[24m     The string literal to pass the shell that results in
1438                           a single newline character when used outside of any
1439                           quoting characters.
1440               Example:
1441
1442               .SHELL: name=ksh path=/bin/ksh hasErrCtl=true \
1443                       check="set -e" ignore="set +e" \
1444                       echo="set -v" quiet="set +v" filter="set +v" \
1445                       echoFlag=v errFlag=e newline="'\n'"
1446
1447      \e[1m.SILENT  \e[22mApply the \e[1m.SILENT \e[22mattribute to any specified sources.  If no
1448               sources are specified, the \e[1m.SILENT \e[22mattribute is applied to every
1449               command in the file.
1450
1451      \e[1m.STALE   \e[22mThis target gets run when a dependency file contains stale
1452               entries, having \e[4m.ALLSRC\e[24m set to the name of that dependency file.
1453
1454      \e[1m.SUFFIXES\e[0m
1455               Each source specifies a suffix to \e[1mbmake\e[22m.  If no sources are
1456               specified, any previously specified suffixes are deleted.  It
1457               allows the creation of suffix-transformation rules.
1458
1459               Example:
1460
1461               .SUFFIXES: .o
1462               .c.o:
1463                       cc -o ${.TARGET} -c ${.IMPSRC}
1464
1465 \e[1mENVIRONMENT\e[0m
1466      \e[1mbmake \e[22muses the following environment variables, if they exist: MACHINE,
1467      MACHINE_ARCH, MAKE, MAKEFLAGS, MAKEOBJDIR, MAKEOBJDIRPREFIX, MAKESYSPATH,
1468      PWD, and TMPDIR.
1469
1470      MAKEOBJDIRPREFIX and MAKEOBJDIR may only be set in the environment or on
1471      the command line to \e[1mbmake \e[22mand not as makefile variables; see the descrip-
1472      tion of `\e[4m.OBJDIR\e[24m' for more details.
1473
1474 \e[1mFILES\e[0m
1475      .depend        list of dependencies
1476      Makefile       list of dependencies
1477      makefile       list of dependencies
1478      sys.mk         system makefile
1479      /usr/share/mk  system makefile directory
1480
1481 \e[1mCOMPATIBILITY\e[0m
1482      The basic make syntax is compatible between different versions of make;
1483      however the special variables, variable modifiers and conditionals are
1484      not.
1485
1486    \e[1mOlder versions\e[0m
1487      An incomplete list of changes in older versions of \e[1mbmake\e[22m:
1488
1489      The way that .for loop variables are substituted changed after NetBSD 5.0
1490      so that they still appear to be variable expansions.  In particular this
1491      stops them being treated as syntax, and removes some obscure problems
1492      using them in .if statements.
1493
1494      The way that parallel makes are scheduled changed in NetBSD 4.0 so that
1495      .ORDER and .WAIT apply recursively to the dependent nodes.  The algo-
1496      rithms used may change again in the future.
1497
1498    \e[1mOther make dialects\e[0m
1499      Other make dialects (GNU make, SVR4 make, POSIX make, etc.) do not sup-
1500      port most of the features of \e[1mbmake \e[22mas described in this manual.  Most
1501      notably:
1502
1503            \e[1m+\bo   \e[22mThe \e[1m.WAIT \e[22mand \e[1m.ORDER \e[22mdeclarations and most functionality per-
1504                taining to parallelization.  (GNU make supports parallelization
1505                but lacks these features needed to control it effectively.)
1506
1507            \e[1m+\bo   \e[22mDirectives, including for loops and conditionals and most of
1508                the forms of include files.  (GNU make has its own incompatible
1509                and less powerful syntax for conditionals.)
1510
1511            \e[1m+\bo   \e[22mAll built-in variables that begin with a dot.
1512
1513            \e[1m+\bo   \e[22mMost of the special sources and targets that begin with a dot,
1514                with the notable exception of \e[1m.PHONY\e[22m, \e[1m.PRECIOUS\e[22m, and \e[1m.SUFFIXES\e[22m.
1515
1516            \e[1m+\bo   \e[22mVariable modifiers, except for the
1517                      :old=new
1518                string substitution, which does not portably support globbing
1519                with `%' and historically only works on declared suffixes.
1520
1521            \e[1m+\bo   \e[22mThe \e[1m$> \e[22mvariable even in its short form; most makes support this
1522                functionality but its name varies.
1523
1524      Some features are somewhat more portable, such as assignment with \e[1m+=\e[22m, \e[1m?=\e[22m,
1525      and \e[1m!=\e[22m.  The \e[1m.PATH \e[22mfunctionality is based on an older feature \e[1mVPATH \e[22mfound
1526      in GNU make and many versions of SVR4 make; however, historically its
1527      behavior is too ill-defined (and too buggy) to rely upon.
1528
1529      The \e[1m$@ \e[22mand \e[1m$< \e[22mvariables are more or less universally portable, as is the
1530      \e[1m$(MAKE) \e[22mvariable.  Basic use of suffix rules (for files only in the cur-
1531      rent directory, not trying to chain transformations together, etc.) is
1532      also reasonably portable.
1533
1534 \e[1mSEE ALSO\e[0m
1535      mkdep(1)
1536
1537 \e[1mHISTORY\e[0m
1538      \e[1mbmake \e[22mis derived from NetBSD make(1).  It uses autoconf to facilitate
1539      portability to other platforms.
1540
1541      A make command appeared in Version 7 AT&T UNIX.  This make implementation
1542      is based on Adam De Boor's pmake program which was written for Sprite at
1543      Berkeley.  It was designed to be a parallel distributed make running jobs
1544      on different machines using a daemon called ``customs''.
1545
1546      Historically the target/dependency ``FRC'' has been used to FoRCe
1547      rebuilding (since the target/dependency does not exist... unless someone
1548      creates an ``FRC'' file).
1549
1550 \e[1mBUGS\e[0m
1551      The make syntax is difficult to parse without actually acting on the
1552      data.  For instance, finding the end of a variable's use should involve
1553      scanning each of the modifiers, using the correct terminator for each
1554      field.  In many places make just counts {} and () in order to find the
1555      end of a variable expansion.
1556
1557      There is no way of escaping a space character in a filename.
1558
1559 FreeBSD 11.3                     June 5, 2020                     FreeBSD 11.3