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