freebsd-src/contrib/bmake/bmake.cat1

is  a  program designed to simplify the maintenance of other pro-
grams.  Its input is a list of specifications  as  to  the  files
upon  which  programs  and  other  files depend.  If no option is
given, tries to open then in order to  find  the  specifications.
If  the file exists, it is read, see This manual page is intended
as a reference document only.  For a more thorough description of
and makefiles, please refer to (from 1993).   prepends  the  con-
tents  of  the environment variable to the command line arguments
before parsing them.  The options are as follows: Try to be back-
wards compatible by executing a single shell per command  and  by
making  the  sources of a dependency line in sequence.  Change to
before reading the makefiles or doing anything else.  If multiple
options are specified, each is interpreted relative to the previ-
ous one: is equivalent to Define to be 1, in  the  global  scope.
Turn on debugging, and specify which portions of are to print de-
bugging  information.   Unless the flags are preceded by they are
added to the environment variable and are passed on to any  child
make  processes.  By default, debugging information is printed to
standard error, but this can be changed using the debugging flag.
The debugging output is always unbuffered; in addition, if debug-
ging is enabled but debugging output is not directed to  standard
output, the standard output is line buffered.  The available are:
Print  all possible debugging information; equivalent to specify-
ing all of the  debugging  flags.   Print  debugging  information
about archive searching and caching.  Print debugging information
about the current working directory.  Print debugging information
about  conditional evaluation.  Print debugging information about
directory searching and  caching.   Print  debugging  information
about  failed commands and targets.  Specify where debugging out-
put is written.  This must be the last flag, because it  consumes
the  remainder of the argument.  If the character immediately af-
ter the flag is the file is opened in append mode; otherwise  the
file  is overwritten.  If the file name is or debugging output is
written to the standard output or standard error  output  respec-
tively  (and the option has no effect).  Otherwise, the output is
written to the named file.  If the file name ends with the is re-
placed by the pid.  Print debugging information about loop evalu-
ation.  Print the input graph before making anything.  Print  the
input  graph after making everything, or before exiting on error.
Print the input graph before exiting on error.   Print  debugging
information  about hash table operations.  Print debugging infor-
mation about running multiple shells.  Turn on lint checks.  This
throws errors for variable assignments that  do  not  parse  cor-
rectly,  at  the  time of assignment, so the file and line number
are available.  Print commands in Makefiles regardless of whether
or not they are prefixed by or other flags.  Also known as behav-
ior.  Print debugging information about mode decisions about tar-
gets.  Print debugging information about making targets,  includ-
ing  modification  dates.   Don't  delete  the  temporary command
scripts created when running commands.  These  temporary  scripts
are created in the directory referred to by the environment vari-
able,  or  in if is unset or set to the empty string.  The tempo-
rary scripts are created by and have names of the form  This  can
create many files in or so use with care.  Print debugging infor-
mation about makefile parsing.  Print debugging information about
suffix-transformation  rules.   Print debugging information about
target list maintenance.  Force the option to print raw values of
variables, overriding the default behavior set via  Print  debug-
ging  information  about  variable assignment and expansion.  Run
shell commands with so the actual commands are  printed  as  they
are  executed.   Let  environment variables override global vari-
ables within makefiles.  Specify a makefile to  read  instead  of
the  default or If is standard input is read.  Multiple makefiles
may be specified, and are read in the order specified.  Specify a
directory in which to search for  makefiles  and  included  make-
files.   The  system  makefile directory (or directories, see the
option) is automatically included as part of this  list.   Ignore
non-zero  exit  of shell commands in the makefile.  Equivalent to
specifying before each command line in the makefile.  This option
should be specified by the user.  When the option is in use in  a
recursive  build,  this option is passed by a make to child makes
to allow all the make processes in  the  build  to  cooperate  to
avoid overloading the system.  Specify the maximum number of jobs
that  may  have  running at any one time.  If is a floating point
number, or ends with then the value is multiplied by  the  number
of CPUs reported online by The value of is saved in Turns compat-
ibility mode off, unless the option is also specified.  When com-
patibility mode is off, all commands associated with a target are
executed  in  a  single shell invocation as opposed to the tradi-
tional one shell invocation per line.  This can break traditional
scripts which change directories on each command  invocation  and
then  expect  to start with a fresh environment on the next line.
It is more efficient to correct  the  scripts  rather  than  turn
backwards compatibility on.  A job token pool with tokens is used
to  control  the  total number of jobs running.  Each instance of
will wait for a token from the pool before  running  a  new  job.
Continue  processing  after  errors  are encountered, but only on
those targets that do not depend on  the  target  whose  creation
caused the error.  Specify a directory in which to search for and
makefiles  included via the include statement.  The option can be
used multiple times to form a search path.  This  path  overrides
the  default  system include path Furthermore, the system include
path is appended to the search path used for  include  statements
(see  the option).  The system include path can be referenced via
the read-only variable If a directory name in  the  argument  (or
the environment variable) starts with the string searches for the
specified  file  or  directory named in the remaining part of the
argument string.  The search starts with  the  current  directory
and  then  works  upward towards the root of the file system.  If
the search is successful, the resulting  directory  replaces  the
specification  in  the  argument.   This feature allows to easily
search in the current source tree for customized files (e.g.,  by
using as an argument).  Display the commands that would have been
executed,  but do not actually execute them unless the target de-
pends on the special source (see below) or the  command  is  pre-
fixed  with  Display  the commands that would have been executed,
but do not actually execute any of  them;  useful  for  debugging
top-level  makefiles  without descending into subdirectories.  Do
not execute any commands, instead exit 0 if the specified targets
are up to date, and 1 otherwise.  Do not use the  built-in  rules
specified in the system makefile.  Stop processing if an error is
encountered.  This is the default behavior and the opposite of Do
not echo any commands as they are executed.  Equivalent to speci-
fying  before  each command line in the makefile.  When used with
the flag, append a trace record to for each job started and  com-
pleted.   Rather  than  re-building  a target as specified in the
makefile, create it or update its modification time  to  make  it
appear  up-to-date.  Print the value of Do not build any targets.
Multiple instances of this option may be specified; the variables
are printed one per line, with a blank line for each null or  un-
defined variable.  The value printed is extracted from the global
scope  after  all  makefiles have been read.  By default, the raw
variable contents (which may include additional unexpanded  vari-
able  references) are shown.  If contains a it is not interpreted
as a variable name but rather as an expression.  Its value is ex-
panded before printing.  The value is also expanded before print-
ing if is set to true and the option has not been used  to  over-
ride  it.   Note  that  loop-local and target-local variables, as
well as values taken temporarily by global variables during make-
file processing, are not accessible via this option.   The  debug
mode  can be used to see these at the cost of generating substan-
tial extraneous output.  Like but all printed variables  are  al-
ways expanded to their complete value.  The last occurrence of or
decides  whether  all  variables  are expanded or not.  Treat any
warnings during makefile parsing as errors.  Print  entering  and
leaving  directory  messages, pre and post processing.  Don't ex-
port variables passed on the command line to the environment  in-
dividually.   Variables  passed on the command line are still ex-
ported via the environment variable.  This option may  be  useful
on  systems which have a small limit on the size of command argu-
ments.  Set the value of the variable  to  Normally,  all  values
passed  on the command line are also exported to sub-makes in the
environment.  The flag disables this behavior.  Variable  assign-
ments should follow options for POSIX compatibility but no order-
ing is enforced.  There are several different types of lines in a
makefile: dependency specifications, shell commands, variable as-
signments, include statements, conditional directives, for loops,
other  directives, and comments.  Lines may be continued from one
line to the next by ending them with  a  backslash  The  trailing
newline  character  and  initial whitespace on the following line
are compressed into a single space.  Dependency lines consist  of
one or more targets, an operator, and zero or more sources.  This
creates  a  relationship where the targets on the sources and are
customarily created from them.  A target  is  considered  out  of
date  if  it  does not exist, or if its modification time is less
than that of any of its sources.  An out-of-date  target  is  re-
created,  but  not until all sources have been examined and them-
selves re-created as needed.  Three operators may be  used:  Many
dependency  lines  may name this target but only one may have at-
tached shell commands.  All sources named in all dependency lines
are considered together, and if needed the  attached  shell  com-
mands  are  run  to create or re-create the target.  If is inter-
rupted, the target is removed.  The same, but the target  is  al-
ways re-created whether or not it is out of date.  Any dependency
line  may  have  attached shell commands, but each one is handled
independently: its sources are considered and the attached  shell
commands  are  run  if  the target is out of date with respect to
(only) those sources.  Thus, different  groups  of  the  attached
shell  commands  may be run depending on the circumstances.  Fur-
thermore, unlike for dependency lines with no  sources,  the  at-
tached  shell commands are always run.  Also unlike the target is
not removed if is interrupted.  All dependency lines mentioning a
particular target  must  use  the  same  operator.   Targets  and
sources  may contain the shell wildcard values and The values and
may only be used as part of the final component of the target  or
source, and only match existing files.  The value need not neces-
sarily  be  used to describe existing files.  Expansion is in di-
rectory order, not alphabetically as done  in  the  shell.   Each
target  may  have  associated  with it one or more lines of shell
commands, normally used to create the target.  Each of the  lines
in  this  script  be preceded by a tab.  (For historical reasons,
spaces are not accepted.)  While targets can occur in many depen-
dency lines if desired, by default only one of these rules may be
followed by a creation script.  If the operator is used, however,
all rules may include scripts, and the respective scripts are ex-
ecuted in the order found.  Each line is treated  as  a  separate
shell command, unless the end of line is escaped with a backslash
in  which case that line and the next are combined.  If the first
characters of the command are any combination of or  the  command
is treated specially.  causes the command not to be echoed before
it  is  executed.  causes the command to be executed even when is
given.  This is similar to the effect of the special source,  ex-
cept that the effect can be limited to a single line of a script.
in compatibility mode causes any non-zero exit status of the com-
mand  line  to be ignored.  When is run in jobs mode with the en-
tire script for the target is fed to a  single  instance  of  the
shell.   In compatibility (non-jobs) mode, each command is run in
a separate process.  If the command contains any shell meta char-
acters it is passed to the shell; otherwise attempts direct  exe-
cution.   If a line starts with and the shell has ErrCtl enabled,
failure of the command line is ignored as in compatibility  mode.
Otherwise  affects  the entire job; the script stops at the first
command line that fails, but the target is  not  deemed  to  have
failed.   Makefiles  should be written so that the mode of opera-
tion does not change their behavior.  For  example,  any  command
which uses or without the intention of changing the directory for
subsequent  commands  should be put in parentheses so it executes
in a subshell.  To force the use of a single  shell,  escape  the
line  breaks so as to make the whole script one command.  For ex-
ample: avoid-chdir-side-effects:         @echo  "Building  $@  in
$$(pwd)"          @(cd  ${.CURDIR}  &&  ${MAKE} $@)         @echo
"Back in $$(pwd)"

ensure-one-shell-regardless-of-mode:         @echo  "Building  $@
in   $$(pwd)";   \          (cd  ${.CURDIR}  &&  ${MAKE}  $@);  \
        echo "Back in $$(pwd)" Since changes the current  working
directory  to  before  executing  any targets, each child process
starts with that as its current working directory.  Variables  in
make behave much like macros in the C preprocessor.  Variable as-
signments  have  the  form where: is a single-word variable name,
consisting, by tradition, of all upper-case letters,  is  one  of
the  variable assignment operators described below, and is inter-
preted according to the variable assignment operator.  Whitespace
around and is discarded.  The five operators that  assign  values
to variables are: Assign the value to the variable.  Any previous
value  is  overwritten.  Append the value to the current value of
the variable, separating them by  a  single  space.   Assign  the
value  to  the variable if it is not already defined.  Expand the
value, then assign it to the variable.  References  to  undefined
variables  are  expanded.   This can cause problems when variable
modifiers are used.  Expand the value and pass it  to  the  shell
for  execution,  then assign the output from the child's standard
output to the variable.  Any newlines in the result are  replaced
with  spaces.  In most contexts where variables are expanded, ex-
pands to a single dollar sign.  In other contexts (most  variable
modifiers,  string  literals  in conditions), expands to a single
dollar sign.  References to variables have the  form  or  If  the
variable name consists of only a single character and the expres-
sion  contains  no  modifiers,  the  surrounding  curly braces or
parentheses are not required.  This shorter form  is  not  recom-
mended.   If the variable name contains a dollar, the name itself
is expanded first.  This allows almost arbitrary variable  names,
however  names  containing  dollar, braces, parentheses or white-
space are really best avoided.  If  the  result  of  expanding  a
nested  variable  expression contains a dollar sign the result is
subject to further expansion.  Variable  substitution  occurs  at
four  distinct  times,  depending  on where the variable is being
used.  Variables in dependency lines are expanded as the line  is
read.   Variables  in conditionals are expanded individually, but
only as far as necessary to determine the result  of  the  condi-
tional.   Variables in shell commands are expanded when the shell
command is executed.  loop index variables are expanded  on  each
loop  iteration.  Note that other variables are not expanded when
composing the body of a loop, so the following example code: .for
i in 1 2 3 a+=     ${i} j=      ${i} b+=     ${j} .endfor

all:         @echo ${a}         @echo ${b} prints: 1 2 3  3  3  3
After  the  loop  is executed: contains which expands to contains
which expands to contains which expands to  and  further  to  The
four  different  classes  of  variables  (in  order of increasing
precedence) are: Variables defined as part of environment.  Vari-
ables defined in the makefile or in  included  makefiles.   Vari-
ables  defined  as  part of the command line.  Variables that are
defined specific to a certain target.  Local variables can be set
on a dependency line, unless is set  to  The  rest  of  the  line
(which already has had global variables expanded) is the variable
value.  For example: COMPILER_WRAPPERS= ccache distcc icecc

${OBJS}:  .MAKE.META.CMP_FILTER=${COMPILER_WRAPPERS:S,^,N,}  Only
the targets are impacted by that filter (in mode) and simply  en-
abling/disabling any of the compiler wrappers does not render all
of  those targets out-of-date.  target-local variable assignments
behave differently in that; Only appends to a previous local  as-
signment for the same target and variable.  Is redundant with re-
spect to global variables, which have already been expanded.  The
seven  built-in  local variables are: The list of all sources for
this target; also known as The name of  the  archive  file;  also
known  as  In  suffix-transformation  rules, the name/path of the
source from which the target is to be transformed  (the  source);
also  known  as It is not defined in explicit rules.  The name of
the archive member; also known as The list of  sources  for  this
target  that  were  deemed out-of-date; also known as The name of
the target with suffix (if declared in removed; also known as The
name of the target; also known as For  compatibility  with  other
makes  this is an alias for in archive member rules.  The shorter
forms and are permitted for backward compatibility with  histori-
cal  makefiles  and  legacy  POSIX  make and are not recommended.
Variants of these variables with the punctuation followed immedi-
ately by or e.g. are legacy forms equivalent  to  using  the  and
modifiers.  These forms are accepted for compatibility with make-
files and POSIX but are not recommended.  Four of the local vari-
ables may be used in sources on dependency lines because they ex-
pand  to  the  proper  value  for each target on the line.  These
variables are and In addition, sets or knows about the  following
variables:  The list of all targets encountered in the makefiles.
If evaluated during makefile parsing, lists  only  those  targets
encountered  thus  far.   A  path to the directory where was exe-
cuted.  Refer to the description of for more details.  Is used in
error handling, see Is used in error handling, see Is used in er-
ror handling, see Is used in error handling in mode, see Is  used
in  error  handling,  see The directory of the file this makefile
was included from.  The filename of the file  this  makefile  was
included  from.   The  machine  hardware  name,  see  The machine
processor architecture name, see The name that was executed  with
The  same as for compatibility.  The preferred variable to use is
the environment variable because it is more compatible with other
make variants and cannot be confused with the special target with
the same name.  Names the makefile (default from which  generated
dependencies  are read.  If set to do not print error information
at the end.  A boolean that controls the default behavior of  the
option.   If  true,  variable  values  printed with are fully ex-
panded; if false, the raw variable contents  (which  may  include
additional  unexpanded  variable references) are shown.  The list
of variables exported by The top-level makefile that is currently
read, as given in the command line.  The environment variable may
contain anything that may be specified on command line.  Anything
specified on command line is appended to the variable,  which  is
then  added  to  the  environment for all programs that executes.
The numeric group ID of the user running It is read-only.  If  is
run  with the output for each target is prefixed with a token the
first part of which can be controlled via If is empty,  no  token
is  printed.   For  example, setting to would produce tokens like
making it  easier  to  track  the  degree  of  parallelism  being
achieved.   The argument to the option.  A read-only boolean that
indicates whether the option supports use of The recursion  depth
of The top-level instance of has level 0, and each child make has
its  parent  level  plus  1.   This allows tests like: to protect
things which should only be evaluated in the  top-level  instance
of  The name of the environment variable that stores the level of
nested calls to The ordered list of makefile names (default  that
looks  for.   The  list  of makefiles read by which is useful for
tracking dependencies.  Each makefile is recorded only once,  re-
gardless  of  the number of times read.  In mode, provides a list
of prefixes which match the directories controlled by If  a  file
that  was generated outside of but within said bailiwick is miss-
ing, the current target is considered out-of-date.  In  mode,  it
can  (very rarely!) be useful to filter command lines before com-
parison.  This variable can be set to a set of modifiers that are
applied to each line of the old and new command that  differ,  if
the filtered commands still differ, the target is considered out-
of-date.   In mode, this variable contains a list of all the meta
files updated.  If not empty, it can be used to trigger  process-
ing  of  In  mode,  this variable contains a list of all the meta
files used (updated or not).  This list can be  used  to  process
the  meta  files  to  extract dependency information.  Provides a
list of variable modifiers to apply to each pathname.  Ignore  if
the  expansion  is an empty string.  Provides a list of path pre-
fixes that should be ignored; because the contents  are  expected
to  change over time.  The default list includes: Provides a list
of patterns to match against pathnames.  Ignore any  that  match.
Defines  the  message printed for each meta file updated in mode.
The default value is: Processed after reading all makefiles.  Af-
fects the mode that runs in.  It can contain these keywords: Like
puts into mode.  Puts into mode, where meta files are created for
each target to capture the command run, the output generated, and
if is available, the system calls which are of  interest  to  The
captured  output  can  be  useful when diagnosing errors.  By de-
fault, does not create files in This can be overridden by setting
to a value which represents true.  If is  true,  a  missing  file
makes  the  target out-of-date.  If is true, missing filemon data
makes the target out-of-date.  Do not use For debugging,  it  can
be  useful  to  include the environment in the file.  If in mode,
print a clue about the target being built.  This is useful if the
build is otherwise running silently.  The message printed is  the
expanded  value  of Some makefiles have commands which are simply
not stable.  This keyword causes them to be ignored for determin-
ing whether a target is out of date in  mode.   See  also  If  is
true,  when a .meta file is created, mark the target In both com-
pat and parallel mode, do not make the targets in the  usual  or-
der, but instead randomize their order.  This mode can be used to
detect  undeclared  dependencies  between  files.  Used to create
files in a separate directory, see Used to force a  separate  di-
rectory  for  the  created  files,  even if that directory is not
writable, see Used to create files in a separate  directory,  see
The  name  of  the  operating  system, see It is read-only.  This
variable is used to record the names of variables assigned to  on
the  command  line,  so that they may be exported as part of This
behavior can be disabled by assigning an empty value to within  a
makefile.  Extra variables can be exported from a makefile by ap-
pending  their  names to is re-exported whenever is modified.  If
was built with support, this is set to the  path  of  the  device
node.   This  allows  makefiles  to  test  for this support.  The
process ID of It is read-only.  The parent process ID  of  It  is
read-only.   When  stops  due to an error, it sets to the name of
the target that failed, to the exit status of the failed  target,
to  the  commands of the failed target, and in mode, it also sets
to the and to the path of the meta file (if any)  describing  the
failed  target.  It then prints its name and the value of as well
as the value of any variables named in  If  true,  are  preserved
when doing assignments.  The default is false, for backwards com-
patibility.   Set to true for compatability with other makes.  If
set to false, becomes per normal evaluation rules.  If set to ap-
parent variable assignments in dependency lines  are  treated  as
normal  sources.   The numeric ID of the user running It is read-
only.  This variable is simply assigned a  newline  character  as
its  value.   It  is read-only.  This allows expansions using the
modifier to put a newline between iterations of the  loop  rather
than a space.  For example, in case of an error, prints the vari-
able  names and their values using: A path to the directory where
the targets are built.  Its value is determined by trying  to  to
the  following  directories  in  order and using the first match:
(Only if is set in the  environment  or  on  the  command  line.)
(Only  if  is  set  in  the  environment or on the command line.)
Variable expansion is performed on the value before it  is  used,
so  expressions  such  as may be used.  This is especially useful
with may be modified in the makefile via the  special  target  In
all  cases,  changes to the specified directory if it exists, and
sets and to that directory before executing any targets.   Except
in  the case of an explicit target, checks that the specified di-
rectory is writable and ignores it if not.   This  check  can  be
skipped by setting the environment variable to The directory name
of  the  current makefile being parsed.  The basename of the cur-
rent makefile being parsed.  This variable and are both set  only
while  the  makefiles  are being parsed.  To retain their current
values, assign them to a variable using assignment with expansion
The space-separated list of directories that searches for  files.
To  update  this  search list, use the special target rather than
modifying the variable directly.  Is set in POSIX mode,  see  the
special  target.   Alternate path to the current directory.  nor-
mally sets to the canonical path given by However, if  the  envi-
ronment  variable  is  set and gives a path to the current direc-
tory, sets to the value of instead.  This behavior is disabled if
is set or contains a variable transform.  is set to the value  of
for  all programs which executes.  The pathname of the shell used
to run target scripts.  It is read-only.  The list of known  suf-
fixes.  It is read-only.  The space-separated list of directories
that  searches  for  makefiles, referred to as the system include
path.  To update this search list, use the special target  rather
than modifying the variable which is read-only.  The list of tar-
gets  explicitly  specified  on  the  command  line, if any.  The
colon-separated list of  directories  that  searches  for  files.
This  variable  is supported for compatibility with old make pro-
grams only, use instead.  The general format of a variable expan-
sion is: Each modifier begins with a colon.  To escape  a  colon,
precede  it  with a backslash A list of indirect modifiers can be
specified via a variable, as follows:

In this case, the first modifier in the does  not  start  with  a
colon,  since  that colon already occurs in the referencing vari-
able.  If any of the modifiers in  the  contains  a  dollar  sign
these  must  be doubled to avoid early expansion.  Some modifiers
interpret the expression value as a single string,  others  treat
the  expression  value  as  a whitespace-separated list of words.
When splitting a string into words, whitespace can be escaped us-
ing double quotes, single quotes and  backslashes,  like  in  the
shell.   The  quotes  and  backslashes are retained in the words.
The supported modifiers are: Replaces each word with its  suffix.
Replaces  each  word  with its dirname.  Selects only those words
that match The standard shell  wildcard  characters  and  may  be
used.  The wildcard characters may be escaped with a backslash As
a  consequence  of  the way values are split into words, matched,
and then joined, the construct removes all leading  and  trailing
whitespace  and  normalizes  the  inter-word  spacing to a single
space.  This is the opposite of  selecting  all  words  which  do
match  Orders  the words lexicographically.  Orders the words nu-
merically.  A number followed by one of or is multiplied  by  the
appropriate  factor,  which is 1024 for 1048576 for or 1073741824
for Both upper- and lower-case letters are accepted.  Orders  the
words  in reverse lexicographical order.  Orders the words in re-
verse numerical order.  Shuffles the words.  The results are dif-
ferent each time you are referring to the modified variable;  use
the  assignment with expansion to prevent such behavior.  For ex-
ample,   LIST=                   uno   due   tre   quattro   RAN-
DOM_LIST=            ${LIST:Ox}                       STATIC_RAN-
DOM_LIST:=    ${LIST:Ox}

all:           @echo   "${RANDOM_LIST}"           @echo   "${RAN-
DOM_LIST}"          @echo  "${STATIC_RANDOM_LIST}"          @echo
"${STATIC_RANDOM_LIST}" may produce output  similar  to:  quattro
due tre uno tre due quattro uno due uno quattro tre due uno quat-
tro  tre  Quotes every shell meta-character in the value, so that
it can be passed safely to the shell.  Quotes every  shell  meta-
character  in  the  value, and also doubles characters so that it
can be passed safely through recursive  invocations  of  This  is
equivalent  to Replaces each word with everything but its suffix.
The value is an integer sequence representing the  words  of  the
original  value,  or  the  supplied The value is interpreted as a
format string for using producing the formatted timestamp.  Note:
the format should only be used with If a value is not provided or
is 0, the current time is used.  Computes a 32-bit  hash  of  the
value  and  encodes it as 8 hex digits.  The value is interpreted
as a format string for using producing the  formatted  timestamp.
If  a  value  is  not provided or is 0, the current time is used.
Call with each word as pathname; use as the new value.  If fails;
use or current time.  If is set to then failure will cause an er-
ror.  Attempts to convert the value to an absolute path using  If
that fails, the value is unchanged.  Converts the value to lower-
case  letters.   When  joining  the  words  after a modifier that
treats the value as words, the words are normally separated by  a
space.   This  modifier changes the separator to the character If
is omitted, no separator is used.  The common escapes  (including
octal numeric codes) work as expected.  Converts the value to up-
per-case letters.  Causes subsequent modifiers to treat the value
as  a single word (possibly containing embedded whitespace).  See
also Causes the value to be treated as a list of words.  See also
Modifies the first occurrence of in each word of the  value,  re-
placing  it  with  If  a is appended to the last delimiter of the
pattern, all occurrences in each word are replaced.  If a is  ap-
pended  to  the last delimiter of the pattern, only the first oc-
currence is affected.  If a is appended to the last delimiter  of
the  pattern,  the  value is treated as a single word.  If begins
with a caret is anchored at the beginning of each word.  If  ends
with  a  dollar sign it is anchored at the end of each word.  In-
side an ampersand is replaced by (without the  anchoring  or  Any
character may be used as the delimiter for the parts of the modi-
fier  string.   The anchoring, ampersand and delimiter characters
can be escaped with a backslash Both and may contain  nested  ex-
pressions.   To  prevent a dollar sign from starting a nested ex-
pression, escape it with a backslash.  The  modifier  works  like
the  modifier except that the old and new strings, instead of be-
ing simple strings, are an extended regular expression  (see  and
an  Normally, the first occurrence of the pattern in each word of
the value is substituted with The modifier causes  the  substitu-
tion  to  apply to at most one word; the modifier causes the sub-
stitution to apply to as many instances of the search pattern  as
occur  in  the  word or words it is found in; the modifier causes
the value to be treated as a single word (possibly containing em-
bedded whitespace).  As for the modifier, the and  are  subjected
to variable expansion before being parsed as regular expressions.
Replaces  each word with its last path component (basename).  Re-
moves adjacent duplicate words (like If the  variable  name  (not
its value), when parsed as a conditional expression, evaluates to
true,  return  as  its  value  the otherwise return the Since the
variable name is used as the expression, :?  must  be  the  first
modifier  after  the variable name which, of course, usually con-
tains variable expansions.  A common error is trying to  use  ex-
pressions  like which actually tests defined(NUMBERS).  To deter-
mine if any words match you need to use something like:  This  is
the  style substitution.  It can only be the last modifier speci-
fied, as a in either or is treated as a regular character, not as
the end of the modifier.  If does not contain the pattern  match-
ing character and the word ends with or equals it, that suffix is
replaced  with  Otherwise,  the first in matches a possibly empty
substring of arbitrary characters, and if the  whole  pattern  is
found  in  the  word,  the matching part is replaced with and the
first occurrence of in (if any) is replaced  with  the  substring
matched  by the Both and may contain nested expressions.  To pre-
vent a dollar sign from starting a nested expression,  escape  it
with  a backslash.  This is the loop expansion mechanism from the
OSF Development Environment (ODE) make.  Unlike loops,  expansion
occurs at the time of reference.  For each word in the value, as-
sign  the word to the variable named and evaluate The ODE conven-
tion is that should start and end with  a  period,  for  example:
However,  a  single-letter variable is often more readable: Saves
the current variable value in or the named for  later  reference.
Example  usage:  M_cmpv.units  =  1  1000  1000000  M_cmpv = S,.,
,g:_:range:@i@+           $${_:[-$$i]}            \            \*
$${M_cmpv.units:[$$i]}@:S,^,expr 0 ,1:sh


Here  is  used  to save the result of the modifier which is later
referenced using the index values from If the variable  is  unde-
fined,  the  optional  (which may be empty) is the value.  If the
variable is defined, the existing value is returned.  This is an-
other ODE make feature.   It  is  handy  for  setting  per-target
CFLAGS  for instance: If a value is only required if the variable
is undefined, use: If the variable  is  defined,  (which  may  be
empty) is the value.  The name of the variable is the value.  The
path  of  the node which has the same name as the variable is the
value.  If no such node exists or its path is null, the  name  of
the  variable  is  used.  In order for this modifier to work, the
name (node) must at least have appeared on the right-hand side of
a dependency.  The output of running is the value.  The value  is
run  as  a  command,  and  the output becomes the new value.  The
variable is assigned the value after substitution.  This modifier
and its variations are useful in obscure situations such as want-
ing to set a variable at a point where a target's shell  commands
are  being  parsed.   These assignment modifiers always expand to
nothing.  The helps avoid false matches with the  style  modifier
and  since substitution always occurs, the form is vaguely appro-
priate.  As for but only if the variable does not already have  a
value.   Append  to  the  variable.   Assign the output of to the
variable.  Selects one or more words from the value, or  performs
other  operations  related to the way in which the value is split
into words.  An empty value, or a value that consists entirely of
white-space, is treated as a single word.  For  the  purposes  of
the  modifier, the words are indexed both forwards using positive
integers (where index 1 represents the first word), and backwards
using negative integers  (where  index  -1  represents  the  last
word).   The is subjected to variable expansion, and the expanded
result is then interpreted as follows: Selects a single word from
the value.  Selects all words from to  inclusive.   For  example,
selects  all  words from the second word to the last word.  If is
greater than the words are output in reverse order.  For example,
selects all the words from last to first.  If the list is already
ordered, this effectively reverses the list, but it is more effi-
cient to use instead of Causes subsequent modifiers to treat  the
value as a single word (possibly containing embedded whitespace).
Analogous  to  the  effect of in Bourne shell.  Means the same as
Causes subsequent modifiers to treat the value as a  sequence  of
words  delimited  by  whitespace.   Analogous to the effect of in
Bourne shell.  Returns the number of words in the value.   offers
directives  for  including makefiles, conditionals and for loops.
All these directives are identified by a line  beginning  with  a
single  dot  character, followed by the keyword of the directive,
such as or Files are included with either  or  Variables  between
the angle brackets or double quotes are expanded to form the file
name.   If  angle brackets are used, the included makefile is ex-
pected to be in the system makefile directory.  If double  quotes
are  used, the including makefile's directory and any directories
specified using the option are searched before the  system  make-
file  directory.   For  compatibility  with  other make variants,
(without leading dot) is also accepted.  If the include statement
is written as or as errors locating and/or opening include  files
are ignored.  If the include statement is written as not only are
errors  locating  and/or opening include files ignored, but stale
dependencies within the included file are ignored  just  like  in
The  directives  for exporting and unexporting variables are: Ex-
port the specified global variable.  If no variable list is  pro-
vided,  all  globals  are  exported except for internal variables
(those that start with This is  not  affected  by  the  flag,  so
should  be  used with caution.  For compatibility with other make
programs, (without leading dot) is also  accepted.   Appending  a
variable name to is equivalent to exporting a variable.  The same
as  except  that  the variable is not appended to This allows ex-
porting a value to the environment which is different  from  that
used  by  internally.   The  same as except that variables in the
value are not expanded.  The opposite of The specified global  is
removed from If no variable list is provided, all globals are un-
exported,  and deleted.  Unexport all globals previously exported
and clear the environment inherited from the parent.  This opera-
tion causes a memory leak of the original environment, so  should
be  used  sparingly.  Testing for being 0 would make sense.  Also
note that any variables which originated in the  parent  environ-
ment  should  be  explicitly  preserved if desired.  For example:
PATH := ${PATH} Would result in an  environment  containing  only
which is the minimal useful environment.  Actually is also pushed
into  the  new environment.  The directives for printing messages
to the output are: The message is printed along with the name  of
the makefile and line number.  The message prefixed by is printed
along with the name of the makefile and line number.  The message
is  printed  along with the name of the makefile and line number,
exits immediately.  The directives for conditionals are: Test the
value of an expression.  Test  whether  a  variable  is  defined.
Test  whether  a  variable is not defined.  Test the target being
requested.  Test the target being requested.  Reverse  the  sense
of the last conditional.  A combination of followed by A combina-
tion of followed by A combination of followed by A combination of
followed by A combination of followed by End the body of the con-
ditional.  The may be any one of the following: Logical OR.  Log-
ical  AND; of higher precedence than only evaluates a conditional
as far as is necessary to determine its value.   Parentheses  can
be  used to override the operator precedence.  The boolean opera-
tor may be used to logically negate an  expression,  typically  a
function  call.  It is of higher precedence than The value of may
be any of the following function call expressions:  Evaluates  to
true  if the variable has been defined.  Evaluates to true if the
target was specified as part of command line or was declared  the
default  target  (either implicitly or explicitly, see before the
line containing the conditional.  Evaluates to true if the expan-
sion of the variable, after applying the modifiers, results in an
empty string.  Evaluates to true if the  given  pathname  exists.
If  relative,  the  pathname is searched for on the system search
path (see Evaluates to true  if  the  target  has  been  defined.
Evaluates to true if the target has been defined and has commands
associated with it.  may also be an arithmetic or string compari-
son.   Variable  expansion is performed on both sides of the com-
parison.  If both sides are numeric and neither  is  enclosed  in
quotes,  the  comparison  is  done numerically, otherwise lexico-
graphically.  A string is interpreted as a hexadecimal integer if
it is preceded by otherwise it is interpreted as a decimal float-
ing-point number; octal numbers are not supported.   All  compar-
isons  may use the operators and Numeric comparisons may also use
the operators and If the comparison has neither a comparison  op-
erator  nor  a right side, the expression evaluates to true if it
is nonempty and its numeric value (if any) is not zero.  When  is
evaluating  one  of these conditional expressions, and it encoun-
ters a (whitespace-separated) word it doesn't  recognize,  either
the  or  function  is applied to it, depending on the form of the
conditional.  If the form is or the function is  applied.   Simi-
larly,  if the form is or the function is applied.  If the condi-
tional evaluates to true, parsing of the  makefile  continues  as
before.   If it evaluates to false, the following lines until the
corresponding variant, or are skipped.  For loops  are  typically
used to apply a set of rules to a list of files.  The syntax of a
for  loop is: The is expanded and then split into words.  On each
iteration of the loop, one word is taken and assigned to each  in
order,  and these are substituted into the inside the body of the
for loop.  The number of words must come out even;  that  is,  if
there are three iteration variables, the number of words provided
must be a multiple of three.  If is encountered within a loop, it
causes  early  termination  of the loop, otherwise a parse error.
Un-define the specified global variables.  Only global  variables
can  be  un-defined.   Comments begin with a hash character, any-
where but in a shell command line, and continue to the end of  an
unescaped new line.  Target is never out of date, but always exe-
cute  commands anyway.  Ignore any errors from the commands asso-
ciated with this target, exactly as if they all were preceded  by
a dash Mark all sources of this target as being up to date.  Exe-
cute  the commands associated with this target even if the or op-
tions were specified.  Normally used to mark recursive  Create  a
meta  file  for  the target, even if it is flagged as or Usage in
conjunction with is the most likely case.  In mode, the target is
out-of-date if the meta file is missing.  Do not  create  a  meta
file for the target.  Meta files are also not created for or tar-
gets.   Ignore differences in commands when deciding if target is
out of date.  This is useful if  the  command  contains  a  value
which  always changes.  If the number of commands change, though,
the target is still considered out of date.  The same effect  ap-
plies  to  any  command  line that uses the variable which can be
used for that purpose even when not otherwise needed or desired:

skip-compare-for-some:            @echo    this    is    compared
        @echo  this  is not ${.OODATE:M.NOMETA_CMP}         @echo
this is also compared

The pattern suppresses any expansion of  the  unwanted  variable.
Do not search for the target in the directories specified by Nor-
mally  selects the first target it encounters as the default tar-
get to be built if no target was specified.  This source prevents
this target from being selected.  If a target is marked with this
attribute and can't figure out how to create it, it ignores  this
fact  and  assumes  the file isn't needed or already exists.  The
target does not correspond to an actual file; it is  always  con-
sidered  to  be  out of date, and is not created with the option.
Suffix-transformation rules are not applied to targets.  When  is
interrupted,  it  normally  removes  any  partially made targets.
This source prevents the target from being removed.  Synonym  for
Do  not echo any of the commands associated with this target, ex-
actly as if they all were preceded by an at sign Turn the  target
into version of a macro.  When the target is used as a source for
another  target, the other target acquires the commands, sources,
and attributes (except for of the source.  If the target  already
has  commands,  the target's commands are appended to them.  Like
but instead of appending, prepend the target commands to the tar-
get.  If appears in a dependency line, the sources  that  precede
it  are  made  before  the  sources  that succeed it in the line.
Since the dependents of files are not made until the file  itself
could  be made, this also stops the dependents being built unless
they are needed for another branch of the  dependency  tree.   So
given:  x:  a  .WAIT  b          echo  x  a:         echo a b: b1
        echo b b1:         echo b1

the output is always The ordering imposed by is only relevant for
parallel makes.  Special targets may not be included  with  other
targets,  i.e.  they must be the only target specified.  Any com-
mand lines attached to this target are executed  before  anything
else  is  done.   This is sort of a rule for any target (that was
used only as a source) that can't figure out  any  other  way  to
create.  Only the shell script is used.  The variable of a target
that  inherits commands is set to the target's own name.  If this
target is present in the makefile, it  globally  causes  make  to
delete  targets  whose  commands fail.  (By default, only targets
whose commands are  interrupted  during  execution  are  deleted.
This  is  the  historical behavior.)  This setting can be used to
help prevent half-finished or malformed targets from  being  left
around  and  corrupting  future  rebuilds.  Any command lines at-
tached to this target are executed after everything else is  done
successfully.  Any command lines attached to this target are exe-
cuted when another target fails.  See for the variables that will
be  set.   Mark  each  of  the sources with the attribute.  If no
sources are specified, this is the equivalent of  specifying  the
option.  If is interrupted, the commands for this target are exe-
cuted.  If no target is specified when is invoked, this target is
built.   This  target  provides a way to specify flags for at the
time when the makefiles are read.  The flags are as if  typed  to
the  shell, though the option has no effect.  Apply the attribute
to any specified sources.  Disable parallel  mode.   Synonym  for
for compatibility with other pmake variants.  clear the read-only
attribute  from  the  global variables specified as sources.  The
source is a new value for If it exists, changes the current work-
ing directory to it and updates the value of  In  parallel  mode,
the  named  targets are made in sequence.  This ordering does not
add targets to the list of targets to be made.  Since the  depen-
dents  of a target do not get built until the target itself could
be built, unless is built  by  another  part  of  the  dependency
graph,  the  following is a dependency loop: .ORDER: b a b: a The
sources are directories which are to be searched  for  files  not
found in the current directory.  If no sources are specified, any
previously  specified  directories  are  removed  from the search
path.  If the source is the special target, the  current  working
directory  is searched last.  Like but applies only to files with
a particular suffix.  The suffix must have  been  previously  de-
clared  with  Apply  the  attribute to any specified sources.  If
this is the first non-comment line  in  the  main  makefile,  the
variable  is  set to the value and the makefile is included if it
exists, to provide POSIX-compatible default  rules.   If  is  run
with  the flag, only contributes to the default rules.  Apply the
attribute to any specified sources.  If no sources are specified,
the attribute is applied to every target in the  file.   set  the
read-only attribute on the global variables specified as sources.
Sets  the shell that uses to execute commands.  The sources are a
set of pairs.  This is the minimal specification, used to  select
one  of the built-in shell specs; and Specifies the absolute path
to the shell.  Indicates whether the shell supports exit  on  er-
ror.  The command to turn on error checking.  The command to dis-
able  error checking.  The command to turn on echoing of commands
executed.  The command to turn off echoing of commands  executed.
The  output to filter after issuing the command.  It is typically
identical to The flag to pass the shell to enable error checking.
The flag to pass the shell to enable command echoing.  The string
literal to pass the shell that results in a single newline  char-
acter  when  used  outside  of  any quoting characters.  Example:
.SHELL:     name=ksh     path=/bin/ksh      hasErrCtl=true      \
        check="set  -e"  ignore="set  +e" \         echo="set -v"
quiet="set +v" filter="set  +v"  \          echoFlag=v  errFlag=e
newline="'\n'"  Apply the attribute to any specified sources.  If
no sources are specified, the attribute is applied to every  com-
mand  in  the  file.  This target gets run when a dependency file
contains stale entries, having set to the name of that dependency
file.  Each source specifies a suffix to If no sources are speci-
fied, any previously specified suffixes are deleted.   It  allows
the creation of suffix-transformation rules.  Example: .SUFFIXES:
.c  .o  .c.o:          cc -o ${.TARGET} -c ${.IMPSRC} The sources
are directories which are to be added to the system include  path
which  searches  for makefiles.  If no sources are specified, any
previously specified directories are removed from the system  in-
clude  path.   uses  the following environment variables, if they
exist: and and may only be set in the environment or on the  com-
mand  line  to and not as makefile variables; see the description
of for more details.  list of dependencies first default makefile
if no makefile is specified on the command  line  second  default
makefile  if  no makefile is specified on the command line system
makefile system makefile directory The basic make syntax is  com-
patible  between  different  make  variants;  however the special
variables, variable modifiers and conditionals are not.   An  in-
complete  list  of changes in older versions of The way that .for
loop variables are substituted changed after NetBSD 5.0  so  that
they  still appear to be variable expansions.  In particular this
stops them being treated as  syntax,  and  removes  some  obscure
problems  using  them  in  .if statements.  The way that parallel
makes are scheduled changed in NetBSD  4.0  so  that  .ORDER  and
.WAIT  apply  recursively to the dependent nodes.  The algorithms
used may change again in the future.  Other  make  dialects  (GNU
make,  SVR4  make,  POSIX  make, etc.) do not support most of the
features of as described in this manual.  Most notably:  The  and
declarations  and  most  functionality pertaining to paralleliza-
tion.  (GNU make supports parallelization but lacks the  features
needed  to  control  it  effectively.)  Directives, including for
loops and conditionals and most of the forms  of  include  files.
(GNU  make  has its own incompatible and less powerful syntax for
conditionals.)  All built-in variables that  begin  with  a  dot.
Most  of  the  special sources and targets that begin with a dot,
with the notable exception of and Variable modifiers, except  for
the string substitution, which does not portably support globbing
with and historically only works on declared suffixes.  The vari-
able  even in its short form; most makes support this functional-
ity but  its  name  varies.   Some  features  are  somewhat  more
portable,  such as assignment with and The functionality is based
on an older feature found in GNU make and many versions  of  SVR4
make;  however, historically its behavior is too ill-defined (and
too buggy) to rely upon.  The and variables are more or less uni-
versally portable, as is the variable.  Basic use of suffix rules
(for files only in the current directory,  not  trying  to  chain
transformations  together, etc.) is also reasonably portable.  is
derived from NetBSD It uses autoconf to facilitate portability to
other platforms.  A make command appeared in This make  implemen-
tation  is based on Adam de Boor's pmake program, which was writ-
ten for Sprite at Berkeley.  It was designed  to  be  a  parallel
distributed  make running jobs on different machines using a dae-
mon called Historically the target/dependency has  been  used  to
FoRCe  rebuilding (since the target/dependency does not exist ...
unless someone creates an file).  The make syntax is difficult to
parse.  For instance, finding the end of a variable's use  should
involve  scanning each of the modifiers, using the correct termi-
nator for each field.  In many places make just counts {} and  ()
in  order  to  find the end of a variable expansion.  There is no
way of escaping a space character in a filename.  In  jobs  mode,
when  a  target  fails; make will put an error token into the job
token pool.  This will cause all other instances  of  make  using
that  token  pool  to abort the build and exit with error code 6.
Sometimes the attempt to suppress a cascade  of  unnecessary  er-
rors, can result in a seemingly unexplained