1BMAKE(1) BSD General Commands Manual BMAKE(1)
2
4 bmake — maintain program dependencies
5
7 bmake [-BeikNnqrSstWwX] [-C directory] [-D variable] [-d flags]
8 [-f makefile] [-I directory] [-J private] [-j max_jobs]
9 [-m directory] [-T file] [-V variable] [-v variable]
10 [variable=value] [target ...]
11
13 bmake is 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 -f makefile option is given,
16 bmake tries to open ‘makefile’ then ‘Makefile’ in order to find the spec‐
17 ifications. If the file ‘.depend’ exists, it is read, see mkdep(1).
18 This manual page is intended as a reference document only. For a more
20 thorough description of bmake and makefiles, please refer to PMake - A
21 Tutorial (from 1993).
22 bmake prepends the contents of the MAKEFLAGS environment variable to the
24 command line arguments before parsing them.
25 The options are as follows:
27 -B Try to be backwards compatible by executing a single shell per
29 command and by making the sources of a dependency line in se‐
30 quence.
31 -C directory
33 Change to directory before reading the makefiles or doing any‐
34 thing else. If multiple -C options are specified, each is inter‐
35 preted relative to the previous one: -C / -C etc is equivalent to
36 -C /etc.
37 -D variable
39 Define variable to be 1, in the global scope.
40 -d [-]flags
42 Turn on debugging, and specify which portions of bmake are to
43 print debugging information. Unless the flags are preceded by
44 ‘-’, they are added to the MAKEFLAGS environment variable and are
45 passed on to any child make processes. By default, debugging in‐
46 formation is printed to standard error, but this can be changed
47 using the F debugging flag. The debugging output is always un‐
48 buffered; in addition, if debugging is enabled but debugging out‐
49 put is not directed to standard output, the standard output is
50 line buffered. The available flags are:
51 A Print all possible debugging information; equivalent to
53 specifying all of the debugging flags.
54 a Print debugging information about archive searching and
56 caching.
57 C Print debugging information about the current working di‐
59 rectory.
60 c Print debugging information about conditional evaluation.
62 d Print debugging information about directory searching and
64 caching.
65 e Print debugging information about failed commands and
67 targets.
68 F[+]filename
70 Specify where debugging output is written. This must be
71 the last flag, because it consumes the remainder of the
72 argument. If the character immediately after the F flag
73 is ‘+’, the file is opened in append mode; otherwise the
74 file is overwritten. If the file name is ‘stdout’ or
75 ‘stderr’, debugging output is written to the standard
76 output or standard error output respectively (and the ‘+’
77 option has no effect). Otherwise, the output is written
78 to the named file. If the file name ends with ‘.%d’, the
79 ‘%d’ is replaced by the pid.
80 f Print debugging information about loop evaluation.
82 g1 Print the input graph before making anything.
84 g2 Print the input graph after making everything, or before
86 exiting on error.
87 g3 Print the input graph before exiting on error.
89 h Print debugging information about hash table operations.
91 j Print debugging information about running multiple
93 shells.
94 L Turn on lint checks. This throws errors for variable as‐
96 signments that do not parse correctly, at the time of as‐
97 signment, so the file and line number are available.
98 l Print commands in Makefiles regardless of whether or not
100 they are prefixed by ‘@’ or other “quiet” flags. Also
101 known as “loud” behavior.
102 M Print debugging information about “meta” mode decisions
104 about targets.
105 m Print debugging information about making targets, includ‐
107 ing modification dates.
108 n Don't delete the temporary command scripts created when
110 running commands. These temporary scripts are created in
111 the directory referred to by the TMPDIR environment vari‐
112 able, or in /tmp if TMPDIR is unset or set to the empty
113 string. The temporary scripts are created by mkstemp(3),
114 and have names of the form makeXXXXXX. NOTE: This can
115 create many files in TMPDIR or /tmp, so use with care.
116 p Print debugging information about makefile parsing.
118 s Print debugging information about suffix-transformation
120 rules.
121 t Print debugging information about target list mainte‐
123 nance.
124 V Force the -V option to print raw values of variables,
126 overriding the default behavior set via
127 .MAKE.EXPAND_VARIABLES.
128 v Print debugging information about variable assignment and
130 expansion.
131 x Run shell commands with -x so the actual commands are
133 printed as they are executed.
134 -e Let environment variables override global variables within make‐
136 files.
137 -f makefile
139 Specify a makefile to read instead of the default makefile or
140 Makefile. If makefile is ‘-’, standard input is read. Multiple
141 makefiles may be specified, and are read in the order specified.
142 -I directory
144 Specify a directory in which to search for makefiles and included
145 makefiles. The system makefile directory (or directories, see
146 the -m option) is automatically included as part of this list.
147 -i Ignore non-zero exit of shell commands in the makefile. Equiva‐
149 lent to specifying ‘-’ before each command line in the makefile.
150 -J private
152 This option should not be specified by the user.
153 When the -j option is in use in a recursive build, this option is
155 passed by a make to child makes to allow all the make processes
156 in the build to cooperate to avoid overloading the system.
157 -j max_jobs
159 Specify the maximum number of jobs that bmake may have running at
160 any one time. The value of max_jobs is saved in .MAKE.JOBS.
161 Turns compatibility mode off, unless the -B option is also speci‐
162 fied. When compatibility mode is off, all commands associated
163 with a target are executed in a single shell invocation as op‐
164 posed to the traditional one shell invocation per line. This can
165 break traditional scripts which change directories on each com‐
166 mand invocation and then expect to start with a fresh environment
167 on the next line. It is more efficient to correct the scripts
168 rather than turn backwards compatibility on.
169 A job token pool with max_jobs tokens is used to control the to‐
171 tal number of jobs running. Each instance of bmake will wait for
172 a token from the pool before running a new job.
173 -k Continue processing after errors are encountered, but only on
175 those targets that do not depend on the target whose creation
176 caused the error.
177 -m directory
179 Specify a directory in which to search for sys.mk and makefiles
180 included via the <file>-style include statement. The -m option
181 can be used multiple times to form a search path. This path
182 overrides the default system include path /usr/share/mk. Fur‐
183 thermore, the system include path is appended to the search path
184 used for "file"-style include statements (see the -I option).
185 The system include path can be referenced via the read-only vari‐
186 able .SYSPATH.
187 If a directory name in the -m argument (or the MAKESYSPATH envi‐
189 ronment variable) starts with the string ‘.../’, bmake searches
190 for the specified file or directory named in the remaining part
191 of the argument string. The search starts with the current di‐
192 rectory and then works upward towards the root of the file sys‐
193 tem. If the search is successful, the resulting directory re‐
194 places the ‘.../’ specification in the -m argument. This feature
195 allows bmake to easily search in the current source tree for cus‐
196 tomized sys.mk files (e.g., by using ‘.../mk/sys.mk’ as an argu‐
197 ment).
198 -n Display the commands that would have been executed, but do not
200 actually execute them unless the target depends on the .MAKE spe‐
201 cial source (see below) or the command is prefixed with ‘+’.
202 -N Display the commands that would have been executed, but do not
204 actually execute any of them; useful for debugging top-level
205 makefiles without descending into subdirectories.
206 -q Do not execute any commands, instead exit 0 if the specified tar‐
208 gets are up to date, and 1 otherwise.
209 -r Do not use the built-in rules specified in the system makefile.
211 -S Stop processing if an error is encountered. This is the default
213 behavior and the opposite of -k.
214 -s Do not echo any commands as they are executed. Equivalent to
216 specifying ‘@’ before each command line in the makefile.
217 -T tracefile
219 When used with the -j flag, append a trace record to tracefile
220 for each job started and completed.
221 -t Rather than re-building a target as specified in the makefile,
223 create it or update its modification time to make it appear up-
224 to-date.
225 -V variable
227 Print the value of variable. Do not build any targets. Multiple
228 instances of this option may be specified; the variables are
229 printed one per line, with a blank line for each null or unde‐
230 fined variable. The value printed is extracted from the global
231 scope after all makefiles have been read.
232 By default, the raw variable contents (which may include addi‐
234 tional unexpanded variable references) are shown. If variable
235 contains a ‘$’, it is not interpreted as a variable name but
236 rather as an expression. Its value is expanded before printing.
237 The value is also expanded before printing if
238 .MAKE.EXPAND_VARIABLES is set to true and the -dV option has not
239 been used to override it.
240 Note that loop-local and target-local variables, as well as val‐
242 ues taken temporarily by global variables during makefile pro‐
243 cessing, are not accessible via this option. The -dv debug mode
244 can be used to see these at the cost of generating substantial
245 extraneous output.
246 -v variable
248 Like -V, but all printed variables are always expanded to their
249 complete value. The last occurrence of -V or -v decides whether
250 all variables are expanded or not.
251 -W Treat any warnings during makefile parsing as errors.
253 -w Print entering and leaving directory messages, pre and post pro‐
255 cessing.
256 -X Don't export variables passed on the command line to the environ‐
258 ment individually. Variables passed on the command line are
259 still exported via the MAKEFLAGS environment variable. This op‐
260 tion may be useful on systems which have a small limit on the
261 size of command arguments.
262 variable=value
264 Set the value of the variable variable to value. Normally, all
265 values passed on the command line are also exported to sub-makes
266 in the environment. The -X flag disables this behavior. Vari‐
267 able assignments should follow options for POSIX compatibility
268 but no ordering is enforced.
269 There are several different types of lines in a makefile: dependency
271 specifications, shell commands, variable assignments, include statements,
272 conditional directives, for loops, other directives, and comments.
273 Lines may be continued from one line to the next by ending them with a
275 backslash (‘\’). The trailing newline character and initial whitespace
276 on the following line are compressed into a single space.
277
279 Dependency lines consist of one or more targets, an operator, and zero or
280 more sources. This creates a relationship where the targets “depend” on
281 the sources and are customarily created from them. A target is consid‐
282 ered out of date if it does not exist, or if its modification time is
283 less than that of any of its sources. An out-of-date target is re-cre‐
284 ated, but not until all sources have been examined and themselves re-cre‐
285 ated as needed. Three operators may be used:
286 : Many dependency lines may name this target but only one may have
288 attached shell commands. All sources named in all dependency lines
289 are considered together, and if needed the attached shell commands
290 are run to create or re-create the target. If bmake is inter‐
291 rupted, the target is removed.
292 ! The same, but the target is always re-created whether or not it is
294 out of date.
295 :: Any dependency line may have attached shell commands, but each one
297 is handled independently: its sources are considered and the at‐
298 tached shell commands are run if the target is out of date with re‐
299 spect to (only) those sources. Thus, different groups of the at‐
300 tached shell commands may be run depending on the circumstances.
301 Furthermore, unlike :, for dependency lines with no sources, the
302 attached shell commands are always run. Also unlike :, the target
303 is not removed if bmake is interrupted.
304 All dependency lines mentioning a particular target must use the same op‐
306 erator.
307 Targets and sources may contain the shell wildcard values ‘?’, ‘*’, ‘[]’,
309 and ‘{}’. The values ‘?’, ‘*’, and ‘[]’ may only be used as part of the
310 final component of the target or source, and only match existing files.
311 The value ‘{}’ need not necessarily be used to describe existing files.
312 Expansion is in directory order, not alphabetically as done in the shell.
313
315 Each target may have associated with it one or more lines of shell com‐
316 mands, normally used to create the target. Each of the lines in this
317 script must be preceded by a tab. (For historical reasons, spaces are
318 not accepted.) While targets can occur in many dependency lines if de‐
319 sired, by default only one of these rules may be followed by a creation
320 script. If the ‘::’ operator is used, however, all rules may include
321 scripts, and the respective scripts are executed in the order found.
322 Each line is treated as a separate shell command, unless the end of line
324 is escaped with a backslash ‘\’, in which case that line and the next are
325 combined. If the first characters of the command are any combination of
326 ‘@’, ‘+’, or ‘-’, the command is treated specially.
327 @ causes the command not to be echoed before it is executed.
329 + causes the command to be executed even when -n is given.
331 This is similar to the effect of the .MAKE special source,
332 except that the effect can be limited to a single line of a
333 script.
334 - in compatibility mode causes any non-zero exit status of
336 the command line to be ignored.
337 When bmake is run in jobs mode with -j max_jobs, the entire script for
339 the target is fed to a single instance of the shell. In compatibility
340 (non-jobs) mode, each command is run in a separate process. If the com‐
341 mand contains any shell meta characters (‘#=|^(){};&<>*?[]:$`\\n’), it is
342 passed to the shell; otherwise bmake attempts direct execution. If a
343 line starts with ‘-’ and the shell has ErrCtl enabled, failure of the
344 command line is ignored as in compatibility mode. Otherwise ‘-’ affects
345 the entire job; the script stops at the first command line that fails,
346 but the target is not deemed to have failed.
347 Makefiles should be written so that the mode of bmake operation does not
349 change their behavior. For example, any command which uses “cd” or
350 “chdir” without the intention of changing the directory for subsequent
351 commands should be put in parentheses so it executes in a subshell. To
352 force the use of a single shell, escape the line breaks so as to make the
353 whole script one command. For example:
354 avoid-chdir-side-effects:
356 @echo "Building $@ in $$(pwd)"
357 @(cd ${.CURDIR} && ${MAKE} $@)
358 @echo "Back in $$(pwd)"
359 ensure-one-shell-regardless-of-mode:
361 @echo "Building $@ in $$(pwd)"; \
362 (cd ${.CURDIR} && ${MAKE} $@); \
363 echo "Back in $$(pwd)"
364 Since bmake changes the current working directory to ‘.OBJDIR’ before ex‐
366 ecuting any targets, each child process starts with that as its current
367 working directory.
368
370 Variables in make behave much like macros in the C preprocessor.
371 Variable assignments have the form ‘NAME op value’, where:
373 NAME is a single-word variable name, consisting, by tradition,
375 of all upper-case letters,
376 op is one of the variable assignment operators described be‐
378 low, and
379 value is interpreted according to the variable assignment opera‐
381 tor.
382 Whitespace around NAME, op and value is discarded.
384 Variable assignment operators
386 The five operators that assign values to variables are:
387 = Assign the value to the variable. Any previous value is over‐
389 written.
390 += Append the value to the current value of the variable, separating
392 them by a single space.
393 ?= Assign the value to the variable if it is not already defined.
395 := Expand the value, then assign it to the variable.
397 NOTE: References to undefined variables are not expanded. This
399 can cause problems when variable modifiers are used.
400 != Expand the value and pass it to the shell for execution, then as‐
402 sign the output from the child's standard output to the variable.
403 Any newlines in the result are replaced with spaces.
404 Expansion of variables
406 In most contexts where variables are expanded, ‘$$’ expands to a single
407 dollar sign. In other contexts (most variable modifiers, string literals
408 in conditions), ‘\$’ expands to a single dollar sign.
409 References to variables have the form ${name[:modifiers]} or
411 $(name[:modifiers]). If the variable name consists of only a single
412 character and the expression contains no modifiers, the surrounding curly
413 braces or parentheses are not required. This shorter form is not recom‐
414 mended.
415 If the variable name contains a dollar, the name itself is expanded
417 first. This allows almost arbitrary variable names, however names con‐
418 taining dollar, braces, parentheses or whitespace are really best
419 avoided.
420 If the result of expanding a nested variable expression contains a dollar
422 sign (‘$’), the result is subject to further expansion.
423 Variable substitution occurs at four distinct times, depending on where
425 the variable is being used.
426 1. Variables in dependency lines are expanded as the line is read.
428 2. Variables in conditionals are expanded individually, but only as far
430 as necessary to determine the result of the conditional.
431 3. Variables in shell commands are expanded when the shell command is
433 executed.
434 4. .for loop index variables are expanded on each loop iteration. Note
436 that other variables are not expanded when composing the body of a
437 loop, so the following example code:
438 .for i in 1 2 3
440 a+= ${i}
441 j= ${i}
442 b+= ${j}
443 .endfor
444 all:
446 @echo ${a}
447 @echo ${b}
448 prints:
450 1 2 3
452 3 3 3
453 After the loop is executed:
455 a contains ‘${:U1} ${:U2} ${:U3}’, which expands to ‘1 2
457 3’.
458 j contains ‘${:U3}’, which expands to ‘3’.
460 b contains ‘${j} ${j} ${j}’, which expands to ‘${:U3}
462 ${:U3} ${:U3}’ and further to ‘3 3 3’.
463 Variable classes
465 The four different classes of variables (in order of increasing prece‐
466 dence) are:
467 Environment variables
469 Variables defined as part of bmake's environment.
470 Global variables
472 Variables defined in the makefile or in included makefiles.
473 Command line variables
475 Variables defined as part of the command line.
476 Local variables
478 Variables that are defined specific to a certain target.
479 Local variables can be set on a dependency line, unless
481 .MAKE.TARGET_LOCAL_VARIABLES is set to ‘false’. The rest of the line
482 (which already has had global variables expanded) is the variable value.
483 For example:
484 COMPILER_WRAPPERS= ccache distcc icecc
486 ${OBJS}: .MAKE.META.CMP_FILTER=${COMPILER_WRAPPERS:S,^,N,}
488 Only the targets ‘${OBJS}’ are impacted by that filter (in “meta” mode)
490 and simply enabling/disabling any of the compiler wrappers does not ren‐
491 der all of those targets out-of-date.
492 NOTE: target-local variable assignments behave differently in that;
494 += Only appends to a previous local assignment for the same
496 target and variable.
497 := Is redundant with respect to global variables, which have
499 already been expanded.
500 The seven built-in local variables are:
502 .ALLSRC The list of all sources for this target; also known as
504 ‘>’.
505 .ARCHIVE The name of the archive file; also known as ‘!’.
507 .IMPSRC In suffix-transformation rules, the name/path of the
509 source from which the target is to be transformed (the
510 “implied” source); also known as ‘<’. It is not defined
511 in explicit rules.
512 .MEMBER The name of the archive member; also known as ‘%’.
514 .OODATE The list of sources for this target that were deemed out-
516 of-date; also known as ‘?’.
517 .PREFIX The name of the target with suffix (if declared in
519 .SUFFIXES) removed; also known as ‘*’.
520 .TARGET The name of the target; also known as ‘@’. For compati‐
522 bility with other makes this is an alias for .ARCHIVE in
523 archive member rules.
524 The shorter forms (‘>’, ‘!’, ‘<’, ‘%’, ‘?’, ‘*’, and ‘@’) are permitted
526 for backward compatibility with historical makefiles and legacy POSIX
527 make and are not recommended.
528 Variants of these variables with the punctuation followed immediately by
530 ‘D’ or ‘F’, e.g. ‘$(@D)’, are legacy forms equivalent to using the ‘:H’
531 and ‘:T’ modifiers. These forms are accepted for compatibility with AT&T
532 System V UNIX makefiles and POSIX but are not recommended.
533 Four of the local variables may be used in sources on dependency lines
535 because they expand to the proper value for each target on the line.
536 These variables are ‘.TARGET’, ‘.PREFIX’, ‘.ARCHIVE’, and ‘.MEMBER’.
537 Additional built-in variables
539 In addition, bmake sets or knows about the following variables:
540 .ALLTARGETS
542 The list of all targets encountered in the makefiles. If evalu‐
543 ated during makefile parsing, lists only those targets encoun‐
544 tered thus far.
545 .CURDIR
547 A path to the directory where bmake was executed. Refer to the
548 description of ‘PWD’ for more details.
549 .ERROR_CMD
551 Is used in error handling, see MAKE_PRINT_VAR_ON_ERROR.
552 .ERROR_CWD
554 Is used in error handling, see MAKE_PRINT_VAR_ON_ERROR.
555 .ERROR_META_FILE
557 Is used in error handling in “meta” mode, see
558 MAKE_PRINT_VAR_ON_ERROR.
559 .ERROR_TARGET
561 Is used in error handling, see MAKE_PRINT_VAR_ON_ERROR.
562 .INCLUDEDFROMDIR
564 The directory of the file this makefile was included from.
565 .INCLUDEDFROMFILE
567 The filename of the file this makefile was included from.
568 MACHINE
570 The machine hardware name, see uname(1).
571 MACHINE_ARCH
573 The machine processor architecture name, see uname(1).
574 MAKE The name that bmake was executed with (argv[0]).
576 .MAKE The same as MAKE, for compatibility. The preferred variable to
578 use is the environment variable MAKE because it is more compati‐
579 ble with other make variants and cannot be confused with the spe‐
580 cial target with the same name.
581 .MAKE.DEPENDFILE
583 Names the makefile (default ‘.depend’) from which generated de‐
584 pendencies are read.
585 .MAKE.DIE_QUIETLY
587 If set to ‘true’, do not print error information at the end.
588 .MAKE.EXPAND_VARIABLES
590 A boolean that controls the default behavior of the -V option.
591 If true, variable values printed with -V are fully expanded; if
592 false, the raw variable contents (which may include additional
593 unexpanded variable references) are shown.
594 .MAKE.EXPORTED
596 The list of variables exported by bmake.
597 MAKEFILE
599 The top-level makefile that is currently read, as given in the
600 command line.
601 .MAKEFLAGS
603 The environment variable ‘MAKEFLAGS’ may contain anything that
604 may be specified on bmake's command line. Anything specified on
605 bmake's command line is appended to the .MAKEFLAGS variable,
606 which is then added to the environment for all programs that
607 bmake executes.
608 .MAKE.GID
610 The numeric group ID of the user running bmake. It is read-only.
611 .MAKE.JOB.PREFIX
613 If bmake is run with -j, the output for each target is prefixed
614 with a token
615 --- target ---
616 the first part of which can be controlled via .MAKE.JOB.PREFIX.
617 If .MAKE.JOB.PREFIX is empty, no token is printed. For example,
618 setting .MAKE.JOB.PREFIX to
619 ‘${.newline}---${.MAKE:T}[${.MAKE.PID}]’ would produce tokens
620 like
621 ---make[1234] target ---
622 making it easier to track the degree of parallelism being
623 achieved.
624 .MAKE.JOBS
626 The argument to the -j option.
627 .MAKE.LEVEL
629 The recursion depth of bmake. The top-level instance of bmake
630 has level 0, and each child make has its parent level plus 1.
631 This allows tests like: .if ${.MAKE.LEVEL} == 0 to protect things
632 which should only be evaluated in the top-level instance of
633 bmake.
634 .MAKE.LEVEL.ENV
636 The name of the environment variable that stores the level of
637 nested calls to bmake.
638 .MAKE.MAKEFILE_PREFERENCE
640 The ordered list of makefile names (default ‘makefile’,
641 ‘Makefile’) that bmake looks for.
642 .MAKE.MAKEFILES
644 The list of makefiles read by bmake, which is useful for tracking
645 dependencies. Each makefile is recorded only once, regardless of
646 the number of times read.
647 .MAKE.META.BAILIWICK
649 In “meta” mode, provides a list of prefixes which match the di‐
650 rectories controlled by bmake. If a file that was generated out‐
651 side of .OBJDIR but within said bailiwick is missing, the current
652 target is considered out-of-date.
653 .MAKE.META.CMP_FILTER
655 In “meta” mode, it can (very rarely!) be useful to filter command
656 lines before comparison. This variable can be set to a set of
657 modifiers that are applied to each line of the old and new com‐
658 mand that differ, if the filtered commands still differ, the tar‐
659 get is considered out-of-date.
660 .MAKE.META.CREATED
662 In “meta” mode, this variable contains a list of all the meta
663 files updated. If not empty, it can be used to trigger process‐
664 ing of .MAKE.META.FILES.
665 .MAKE.META.FILES
667 In “meta” mode, this variable contains a list of all the meta
668 files used (updated or not). This list can be used to process
669 the meta files to extract dependency information.
670 .MAKE.META.IGNORE_FILTER
672 Provides a list of variable modifiers to apply to each pathname.
673 Ignore if the expansion is an empty string.
674 .MAKE.META.IGNORE_PATHS
676 Provides a list of path prefixes that should be ignored; because
677 the contents are expected to change over time. The default list
678 includes: ‘/dev /etc /proc /tmp /var/run /var/tmp’
679 .MAKE.META.IGNORE_PATTERNS
681 Provides a list of patterns to match against pathnames. Ignore
682 any that match.
683 .MAKE.META.PREFIX
685 Defines the message printed for each meta file updated in “meta
686 verbose” mode. The default value is:
687 Building ${.TARGET:H:tA}/${.TARGET:T}
688 .MAKE.MODE
690 Processed after reading all makefiles. Affects the mode that
691 bmake runs in. It can contain these keywords:
692 compat Like -B, puts bmake into “compat” mode.
694 meta Puts bmake into “meta” mode, where meta files are created
696 for each target to capture the command run, the output
697 generated, and if filemon(4) is available, the system
698 calls which are of interest to bmake. The captured out‐
699 put can be useful when diagnosing errors.
700 curdirOk=bf
702 By default, bmake does not create .meta files in
703 ‘.CURDIR’. This can be overridden by setting bf to a
704 value which represents true.
705 missing-meta=bf
707 If bf is true, a missing .meta file makes the target out-
708 of-date.
709 missing-filemon=bf
711 If bf is true, missing filemon data makes the target out-
712 of-date.
713 nofilemon
715 Do not use filemon(4).
716 env For debugging, it can be useful to include the environ‐
718 ment in the .meta file.
719 verbose
721 If in “meta” mode, print a clue about the target being
722 built. This is useful if the build is otherwise running
723 silently. The message printed is the expanded value of
724 .MAKE.META.PREFIX.
725 ignore-cmd
727 Some makefiles have commands which are simply not stable.
728 This keyword causes them to be ignored for determining
729 whether a target is out of date in “meta” mode. See also
730 .NOMETA_CMP.
731 silent=bf
733 If bf is true, when a .meta file is created, mark the
734 target .SILENT.
735 randomize-targets
737 In both compat and parallel mode, do not make the targets
738 in the usual order, but instead randomize their order.
739 This mode can be used to detect undeclared dependencies
740 between files.
741 MAKEOBJDIR
743 Used to create files in a separate directory, see .OBJDIR.
744 MAKE_OBJDIR_CHECK_WRITABLE
746 Used to force a separate directory for the created files, even if
747 that directory is not writable, see .OBJDIR.
748 MAKEOBJDIRPREFIX
750 Used to create files in a separate directory, see .OBJDIR.
751 .MAKE.OS
753 The name of the operating system, see uname(1). It is read-only.
754 .MAKEOVERRIDES
756 This variable is used to record the names of variables assigned
757 to on the command line, so that they may be exported as part of
758 ‘MAKEFLAGS’. This behavior can be disabled by assigning an empty
759 value to ‘.MAKEOVERRIDES’ within a makefile. Extra variables can
760 be exported from a makefile by appending their names to
761 ‘.MAKEOVERRIDES’. ‘MAKEFLAGS’ is re-exported whenever
762 ‘.MAKEOVERRIDES’ is modified.
763 .MAKE.PATH_FILEMON
765 If bmake was built with filemon(4) support, this is set to the
766 path of the device node. This allows makefiles to test for this
767 support.
768 .MAKE.PID
770 The process ID of bmake. It is read-only.
771 .MAKE.PPID
773 The parent process ID of bmake. It is read-only.
774 MAKE_PRINT_VAR_ON_ERROR
776 When bmake stops due to an error, it sets ‘.ERROR_TARGET’ to the
777 name of the target that failed, ‘.ERROR_CMD’ to the commands of
778 the failed target, and in “meta” mode, it also sets ‘.ERROR_CWD’
779 to the getcwd(3), and ‘.ERROR_META_FILE’ to the path of the meta
780 file (if any) describing the failed target. It then prints its
781 name and the value of ‘.CURDIR’ as well as the value of any vari‐
782 ables named in ‘MAKE_PRINT_VAR_ON_ERROR’.
783 .MAKE.SAVE_DOLLARS
785 If true, ‘$$’ are preserved when doing ‘:=’ assignments. The de‐
786 fault is false, for backwards compatibility. Set to true for
787 compatability with other makes. If set to false, ‘$$’ becomes
788 ‘$’ per normal evaluation rules.
789 .MAKE.TARGET_LOCAL_VARIABLES
791 If set to ‘false’, apparent variable assignments in dependency
792 lines are treated as normal sources.
793 .MAKE.UID
795 The numeric ID of the user running bmake. It is read-only.
796 .newline
798 This variable is simply assigned a newline character as its
799 value. It is read-only. This allows expansions using the :@
800 modifier to put a newline between iterations of the loop rather
801 than a space. For example, in case of an error, bmake prints the
802 variable names and their values using:
803 ${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}
804 .OBJDIR
806 A path to the directory where the targets are built. Its value
807 is determined by trying to chdir(2) to the following directories
808 in order and using the first match:
809 1. ${MAKEOBJDIRPREFIX}${.CURDIR}
811 (Only if ‘MAKEOBJDIRPREFIX’ is set in the environment or on
813 the command line.)
814 2. ${MAKEOBJDIR}
816 (Only if ‘MAKEOBJDIR’ is set in the environment or on the
818 command line.)
819 3. ${.CURDIR}/obj.${MACHINE}
821 4. ${.CURDIR}/obj
823 5. /usr/obj/${.CURDIR}
825 6. ${.CURDIR}
827 Variable expansion is performed on the value before it is used,
829 so expressions such as ${.CURDIR:S,^/usr/src,/var/obj,} may be
830 used. This is especially useful with ‘MAKEOBJDIR’.
831 ‘.OBJDIR’ may be modified in the makefile via the special target
833 ‘.OBJDIR’. In all cases, bmake changes to the specified direc‐
834 tory if it exists, and sets ‘.OBJDIR’ and ‘PWD’ to that directory
835 before executing any targets.
836 Except in the case of an explicit ‘.OBJDIR’ target, bmake checks
838 that the specified directory is writable and ignores it if not.
839 This check can be skipped by setting the environment variable
840 ‘MAKE_OBJDIR_CHECK_WRITABLE’ to “no”.
841 .PARSEDIR
843 The directory name of the current makefile being parsed.
844 .PARSEFILE
846 The basename of the current makefile being parsed. This variable
847 and ‘.PARSEDIR’ are both set only while the makefiles are being
848 parsed. To retain their current values, assign them to a vari‐
849 able using assignment with expansion ‘:=’.
850 .PATH The space-separated list of directories that bmake searches for
852 files. To update this search list, use the special target
853 ‘.PATH’ rather than modifying the variable directly.
854 %POSIX Is set in POSIX mode, see the special ‘.POSIX’ target.
856 PWD Alternate path to the current directory. bmake normally sets
858 ‘.CURDIR’ to the canonical path given by getcwd(3). However, if
859 the environment variable ‘PWD’ is set and gives a path to the
860 current directory, bmake sets ‘.CURDIR’ to the value of ‘PWD’ in‐
861 stead. This behavior is disabled if ‘MAKEOBJDIRPREFIX’ is set or
862 ‘MAKEOBJDIR’ contains a variable transform. ‘PWD’ is set to the
863 value of ‘.OBJDIR’ for all programs which bmake executes.
864 .SHELL The pathname of the shell used to run target scripts. It is
866 read-only.
867 .SUFFIXES
869 The list of known suffixes. It is read-only.
870 .SYSPATH
872 The space-separated list of directories that bmake searches for
873 makefiles, referred to as the system include path. To update
874 this search list, use the special target ‘.SYSPATH’ rather than
875 modifying the variable which is read-only.
876 .TARGETS
878 The list of targets explicitly specified on the command line, if
879 any.
880 VPATH The colon-separated (“:”) list of directories that bmake searches
882 for files. This variable is supported for compatibility with old
883 make programs only, use ‘.PATH’ instead.
884 Variable modifiers
886 The general format of a variable expansion is:
887 ${variable[:modifier[:...]]}
889 Each modifier begins with a colon. To escape a colon, precede it with a
891 backslash ‘\’.
892 A list of indirect modifiers can be specified via a variable, as follows:
894 modifier_variable = modifier[:...]
896 ${variable:${modifier_variable}[:...]}
898 In this case, the first modifier in the modifier_variable does not start
900 with a colon, since that colon already occurs in the referencing vari‐
901 able. If any of the modifiers in the modifier_variable contains a dollar
902 sign (‘$’), these must be doubled to avoid early expansion.
903 Some modifiers interpret the expression value as a single string, others
905 treat the expression value as a whitespace-separated list of words. When
906 splitting a string into words, whitespace can be escaped using double
907 quotes, single quotes and backslashes, like in the shell. The quotes and
908 backslashes are retained in the words.
909 The supported modifiers are:
911 :E Replaces each word with its suffix.
913 :H Replaces each word with its dirname.
915 :Mpattern
917 Selects only those words that match pattern. The standard shell
918 wildcard characters (‘*’, ‘?’, and ‘[]’) may be used. The wildcard
919 characters may be escaped with a backslash (‘\’). As a consequence
920 of the way values are split into words, matched, and then joined,
921 the construct ‘${VAR:M*}’ removes all leading and trailing white‐
922 space and normalizes the inter-word spacing to a single space.
923 :Npattern
925 This is the opposite of ‘:M’, selecting all words which do not match
926 pattern.
927 :O Orders the words lexicographically.
929 :On Orders the words numerically. A number followed by one of ‘k’, ‘M’
931 or ‘G’ is multiplied by the appropriate factor, which is 1024 for
932 ‘k’, 1048576 for ‘M’, or 1073741824 for ‘G’. Both upper- and lower-
933 case letters are accepted.
934 :Or Orders the words in reverse lexicographical order.
936 :Orn
938 Orders the words in reverse numerical order.
939 :Ox Shuffles the words. The results are different each time you are re‐
941 ferring to the modified variable; use the assignment with expansion
942 ‘:=’ to prevent such behavior. For example,
943 LIST= uno due tre quattro
945 RANDOM_LIST= ${LIST:Ox}
946 STATIC_RANDOM_LIST:= ${LIST:Ox}
947 all:
949 @echo "${RANDOM_LIST}"
950 @echo "${RANDOM_LIST}"
951 @echo "${STATIC_RANDOM_LIST}"
952 @echo "${STATIC_RANDOM_LIST}"
953 may produce output similar to:
954 quattro due tre uno
956 tre due quattro uno
957 due uno quattro tre
958 due uno quattro tre
959 :Q Quotes every shell meta-character in the value, so that it can be
961 passed safely to the shell.
962 :q Quotes every shell meta-character in the value, and also doubles ‘$’
964 characters so that it can be passed safely through recursive invoca‐
965 tions of bmake. This is equivalent to ‘:S/\$/&&/g:Q’.
966 :R Replaces each word with everything but its suffix.
968 :range[=count]
970 The value is an integer sequence representing the words of the orig‐
971 inal value, or the supplied count.
972 :gmtime[=timestamp]
974 The value is interpreted as a format string for strftime(3), using
975 gmtime(3), producing the formatted timestamp. If a timestamp value
976 is not provided or is 0, the current time is used.
977 :hash
979 Computes a 32-bit hash of the value and encodes it as 8 hex digits.
980 :localtime[=timestamp]
982 The value is interpreted as a format string for strftime(3), using
983 localtime(3), producing the formatted timestamp. If a timestamp
984 value is not provided or is 0, the current time is used.
985 :mtime[=timestamp]
987 Call stat(2) with each word as pathname; use ‘st_mtime’ as the new
988 value. If stat(2) fails; use timestamp or current time. If
989 timestamp is set to ‘error’, then stat(2) failure will cause an er‐
990 ror.
991 :tA Attempts to convert the value to an absolute path using realpath(3).
993 If that fails, the value is unchanged.
994 :tl Converts the value to lower-case letters.
996 :tsc
998 When joining the words after a modifier that treats the value as
999 words, the words are normally separated by a space. This modifier
1000 changes the separator to the character c. If c is omitted, no sepa‐
1001 rator is used. The common escapes (including octal numeric codes)
1002 work as expected.
1003 :tu Converts the value to upper-case letters.
1005 :tW Causes subsequent modifiers to treat the value as a single word
1007 (possibly containing embedded whitespace). See also ‘:[*]’.
1008 :tw Causes the value to be treated as a list of words. See also ‘:[@]’.
1010 :S/old_string/new_string/[1gW]
1012 Modifies the first occurrence of old_string in each word of the
1013 value, replacing it with new_string. If a ‘g’ is appended to the
1014 last delimiter of the pattern, all occurrences in each word are re‐
1015 placed. If a ‘1’ is appended to the last delimiter of the pattern,
1016 only the first occurrence is affected. If a ‘W’ is appended to the
1017 last delimiter of the pattern, the value is treated as a single
1018 word. If old_string begins with a caret (‘^’), old_string is an‐
1019 chored at the beginning of each word. If old_string ends with a
1020 dollar sign (‘$’), it is anchored at the end of each word. Inside
1021 new_string, an ampersand (‘&’) is replaced by old_string (without
1022 the anchoring ‘^’ or ‘$’). Any character may be used as the delim‐
1023 iter for the parts of the modifier string. The anchoring, ampersand
1024 and delimiter characters can be escaped with a backslash (‘\’).
1025 Both old_string and new_string may contain nested expressions. To
1027 prevent a dollar sign from starting a nested expression, escape it
1028 with a backslash.
1029 :C/pattern/replacement/[1gW]
1031 The :C modifier works like the :S modifier except that the old and
1032 new strings, instead of being simple strings, are an extended regu‐
1033 lar expression pattern (see regex(3)) and an ed(1)-style
1034 replacement. Normally, the first occurrence of the pattern pattern
1035 in each word of the value is substituted with replacement. The ‘1’
1036 modifier causes the substitution to apply to at most one word; the
1037 ‘g’ modifier causes the substitution to apply to as many instances
1038 of the search pattern pattern as occur in the word or words it is
1039 found in; the ‘W’ modifier causes the value to be treated as a sin‐
1040 gle word (possibly containing embedded whitespace).
1041 As for the :S modifier, the pattern and replacement are subjected to
1043 variable expansion before being parsed as regular expressions.
1044 :T Replaces each word with its last path component (basename).
1046 :u Removes adjacent duplicate words (like uniq(1)).
1048 :?true_string:false_string
1050 If the variable name (not its value), when parsed as a .if condi‐
1051 tional expression, evaluates to true, return as its value the
1052 true_string, otherwise return the false_string. Since the variable
1053 name is used as the expression, :? must be the first modifier after
1054 the variable name itself—which, of course, usually contains variable
1055 expansions. A common error is trying to use expressions like
1056 ${NUMBERS:M42:?match:no}
1057 which actually tests defined(NUMBERS). To determine if any words
1058 match “42”, you need to use something like:
1059 ${"${NUMBERS:M42}" != "":?match:no}.
1060 :old_string=new_string
1062 This is the AT&T System V UNIX style substitution. It can only be
1063 the last modifier specified, as a ‘:’ in either old_string or
1064 new_string is treated as a regular character, not as the end of the
1065 modifier.
1066 If old_string does not contain the pattern matching character ‘%’,
1068 and the word ends with old_string or equals it, that suffix is re‐
1069 placed with new_string.
1070 Otherwise, the first ‘%’ in old_string matches a possibly empty sub‐
1072 string of arbitrary characters, and if the whole pattern is found in
1073 the word, the matching part is replaced with new_string, and the
1074 first occurrence of ‘%’ in new_string (if any) is replaced with the
1075 substring matched by the ‘%’.
1076 Both old_string and new_string may contain nested expressions. To
1078 prevent a dollar sign from starting a nested expression, escape it
1079 with a backslash.
1080 :@varname@string@
1082 This is the loop expansion mechanism from the OSF Development Envi‐
1083 ronment (ODE) make. Unlike .for loops, expansion occurs at the time
1084 of reference. For each word in the value, assign the word to the
1085 variable named varname and evaluate string. The ODE convention is
1086 that varname should start and end with a period, for example:
1087 ${LINKS:@.LINK.@${LN} ${TARGET} ${.LINK.}@}
1088 However, a single-letter variable is often more readable:
1090 ${MAKE_PRINT_VAR_ON_ERROR:@v@$v='${$v}'${.newline}@}
1091 :_[=var]
1093 Saves the current variable value in ‘$_’ or the named var for later
1094 reference. Example usage:
1095 M_cmpv.units = 1 1000 1000000
1097 M_cmpv = S,., ,g:_:range:@i@+ $${_:[-$$i]} \
1098 \* $${M_cmpv.units:[$$i]}@:S,^,expr 0 ,1:sh
1099 .if ${VERSION:${M_cmpv}} < ${3.1.12:L:${M_cmpv}}
1101 Here ‘$_’ is used to save the result of the ‘:S’ modifier which is
1103 later referenced using the index values from ‘:range’.
1104 :Unewval
1106 If the variable is undefined, newval is the value. If the variable
1107 is defined, the existing value is returned. This is another ODE
1108 make feature. It is handy for setting per-target CFLAGS for in‐
1109 stance:
1110 ${_${.TARGET:T}_CFLAGS:U${DEF_CFLAGS}}
1111 If a value is only required if the variable is undefined, use:
1112 ${VAR:D:Unewval}
1113 :Dnewval
1115 If the variable is defined, newval is the value.
1116 :L The name of the variable is the value.
1118 :P The path of the node which has the same name as the variable is the
1120 value. If no such node exists or its path is null, the name of the
1121 variable is used. In order for this modifier to work, the name
1122 (node) must at least have appeared on the right-hand side of a de‐
1123 pendency.
1124 :!cmd!
1126 The output of running cmd is the value.
1127 :sh The value is run as a command, and the output becomes the new value.
1129 ::=str
1131 The variable is assigned the value str after substitution. This
1132 modifier and its variations are useful in obscure situations such as
1133 wanting to set a variable at a point where a target's shell commands
1134 are being parsed. These assignment modifiers always expand to noth‐
1135 ing.
1136 The ‘::’ helps avoid false matches with the AT&T System V UNIX style
1138 ‘:=’ modifier and since substitution always occurs, the ‘::=’ form
1139 is vaguely appropriate.
1140 ::?=str
1142 As for ::= but only if the variable does not already have a value.
1143 ::+=str
1145 Append str to the variable.
1146 ::!=cmd
1148 Assign the output of cmd to the variable.
1149 :[range]
1151 Selects one or more words from the value, or performs other opera‐
1152 tions related to the way in which the value is split into words.
1153 An empty value, or a value that consists entirely of white-space, is
1155 treated as a single word. For the purposes of the ‘:[]’ modifier,
1156 the words are indexed both forwards using positive integers (where
1157 index 1 represents the first word), and backwards using negative in‐
1158 tegers (where index -1 represents the last word).
1159 The range is subjected to variable expansion, and the expanded re‐
1161 sult is then interpreted as follows:
1162 index Selects a single word from the value.
1164 start..end
1166 Selects all words from start to end, inclusive. For example,
1167 ‘:[2..-1]’ selects all words from the second word to the last
1168 word. If start is greater than end, the words are output in
1169 reverse order. For example, ‘:[-1..1]’ selects all the words
1170 from last to first. If the list is already ordered, this ef‐
1171 fectively reverses the list, but it is more efficient to use
1172 ‘:Or’ instead of ‘:O:[-1..1]’.
1173 * Causes subsequent modifiers to treat the value as a single
1175 word (possibly containing embedded whitespace). Analogous to
1176 the effect of $* in Bourne shell.
1177 0 Means the same as ‘:[*]’.
1179 @ Causes subsequent modifiers to treat the value as a sequence
1181 of words delimited by whitespace. Analogous to the effect of
1182 $@ in Bourne shell.
1183 # Returns the number of words in the value.
1185
1187 bmake offers directives for including makefiles, conditionals and for
1188 loops. All these directives are identified by a line beginning with a
1189 single dot (‘.’) character, followed by the keyword of the directive,
1190 such as include or if.
1191 File inclusion
1193 Files are included with either .include <file> or .include "file". Vari‐
1194 ables between the angle brackets or double quotes are expanded to form
1195 the file name. If angle brackets are used, the included makefile is ex‐
1196 pected to be in the system makefile directory. If double quotes are
1197 used, the including makefile's directory and any directories specified
1198 using the -I option are searched before the system makefile directory.
1199 For compatibility with other make variants, ‘include file ...’ (without
1201 leading dot) is also accepted.
1202 If the include statement is written as .-include or as .sinclude, errors
1204 locating and/or opening include files are ignored.
1205 If the include statement is written as .dinclude, not only are errors lo‐
1207 cating and/or opening include files ignored, but stale dependencies
1208 within the included file are ignored just like in .MAKE.DEPENDFILE.
1209 Exporting variables
1211 The directives for exporting and unexporting variables are:
1212 .export variable ...
1214 Export the specified global variable. If no variable list is
1215 provided, all globals are exported except for internal variables
1216 (those that start with ‘.’). This is not affected by the -X
1217 flag, so should be used with caution. For compatibility with
1218 other make programs, export variable=value (without leading dot)
1219 is also accepted.
1220 Appending a variable name to .MAKE.EXPORTED is equivalent to ex‐
1222 porting a variable.
1223 .export-env variable ...
1225 The same as ‘.export’, except that the variable is not appended
1226 to .MAKE.EXPORTED. This allows exporting a value to the environ‐
1227 ment which is different from that used by bmake internally.
1228 .export-literal variable ...
1230 The same as ‘.export-env’, except that variables in the value are
1231 not expanded.
1232 .unexport variable ...
1234 The opposite of ‘.export’. The specified global variable is re‐
1235 moved from .MAKE.EXPORTED. If no variable list is provided, all
1236 globals are unexported, and .MAKE.EXPORTED deleted.
1237 .unexport-env
1239 Unexport all globals previously exported and clear the environ‐
1240 ment inherited from the parent. This operation causes a memory
1241 leak of the original environment, so should be used sparingly.
1242 Testing for .MAKE.LEVEL being 0 would make sense. Also note that
1243 any variables which originated in the parent environment should
1244 be explicitly preserved if desired. For example:
1245 .if ${.MAKE.LEVEL} == 0
1247 PATH := ${PATH}
1248 .unexport-env
1249 .export PATH
1250 .endif
1251 Would result in an environment containing only ‘PATH’, which is
1253 the minimal useful environment. Actually ‘.MAKE.LEVEL’ is also
1254 pushed into the new environment.
1255 Messages
1257 The directives for printing messages to the output are:
1258 .info message
1260 The message is printed along with the name of the makefile and
1261 line number.
1262 .warning message
1264 The message prefixed by ‘warning:’ is printed along with the name
1265 of the makefile and line number.
1266 .error message
1268 The message is printed along with the name of the makefile and
1269 line number, bmake exits immediately.
1270 Conditionals
1272 The directives for conditionals are:
1273 .if [!]expression [operator expression ...]
1275 Test the value of an expression.
1276 .ifdef [!]variable [operator variable ...]
1278 Test whether a variable is defined.
1279 .ifndef [!]variable [operator variable ...]
1281 Test whether a variable is not defined.
1282 .ifmake [!]target [operator target ...]
1284 Test the target being requested.
1285 .ifnmake [!]target [operator target ...]
1287 Test the target being requested.
1288 .else Reverse the sense of the last conditional.
1290 .elif [!]expression [operator expression ...]
1292 A combination of ‘.else’ followed by ‘.if’.
1293 .elifdef [!]variable [operator variable ...]
1295 A combination of ‘.else’ followed by ‘.ifdef’.
1296 .elifndef [!]variable [operator variable ...]
1298 A combination of ‘.else’ followed by ‘.ifndef’.
1299 .elifmake [!]target [operator target ...]
1301 A combination of ‘.else’ followed by ‘.ifmake’.
1302 .elifnmake [!]target [operator target ...]
1304 A combination of ‘.else’ followed by ‘.ifnmake’.
1305 .endif End the body of the conditional.
1307 The operator may be any one of the following:
1309 || Logical OR.
1311 && Logical AND; of higher precedence than ‘||’.
1313 bmake only evaluates a conditional as far as is necessary to determine
1315 its value. Parentheses can be used to override the operator precedence.
1316 The boolean operator ‘!’ may be used to logically negate an expression,
1317 typically a function call. It is of higher precedence than ‘&&’.
1318 The value of expression may be any of the following function call expres‐
1320 sions:
1321 defined(varname)
1323 Evaluates to true if the variable varname has been defined.
1324 make(target)
1326 Evaluates to true if the target was specified as part of bmake's
1327 command line or was declared the default target (either implic‐
1328 itly or explicitly, see .MAIN) before the line containing the
1329 conditional.
1330 empty(varname[:modifiers])
1332 Evaluates to true if the expansion of the variable, after apply‐
1333 ing the modifiers, results in an empty string.
1334 exists(pathname)
1336 Evaluates to true if the given pathname exists. If relative, the
1337 pathname is searched for on the system search path (see .PATH).
1338 target(target)
1340 Evaluates to true if the target has been defined.
1341 commands(target)
1343 Evaluates to true if the target has been defined and has commands
1344 associated with it.
1345 Expression may also be an arithmetic or string comparison. Variable ex‐
1347 pansion is performed on both sides of the comparison. If both sides are
1348 numeric and neither is enclosed in quotes, the comparison is done numeri‐
1349 cally, otherwise lexicographically. A string is interpreted as a hexa‐
1350 decimal integer if it is preceded by 0x, otherwise it is interpreted as a
1351 decimal floating-point number; octal numbers are not supported.
1352 All comparisons may use the operators ‘==’ and ‘!=’. Numeric comparisons
1354 may also use the operators ‘<’, ‘<=’, ‘>’ and ‘>=’.
1355 If the comparison has neither a comparison operator nor a right side, the
1357 expression evaluates to true if it is nonempty and its numeric value (if
1358 any) is not zero.
1359 When bmake is evaluating one of these conditional expressions, and it en‐
1361 counters a (whitespace-separated) word it doesn't recognize, either the
1362 “make” or “defined” function is applied to it, depending on the form of
1363 the conditional. If the form is ‘.ifdef’, ‘.ifndef’ or ‘.if’, the
1364 “defined” function is applied. Similarly, if the form is ‘.ifmake’ or
1365 ‘.ifnmake’, the “make” function is applied.
1366 If the conditional evaluates to true, parsing of the makefile continues
1368 as before. If it evaluates to false, the following lines until the cor‐
1369 responding ‘.elif’ variant, ‘.else’ or ‘.endif’ are skipped.
1370 For loops
1372 For loops are typically used to apply a set of rules to a list of files.
1373 The syntax of a for loop is:
1374 .for variable [variable ...] in expression
1376 ⟨make-lines⟩
1377 .endfor
1378 The expression is expanded and then split into words. On each iteration
1380 of the loop, one word is taken and assigned to each variable, in order,
1381 and these variables are substituted into the make-lines inside the body
1382 of the for loop. The number of words must come out even; that is, if
1383 there are three iteration variables, the number of words provided must be
1384 a multiple of three.
1385 If ‘.break’ is encountered within a .for loop, it causes early termina‐
1387 tion of the loop, otherwise a parse error.
1388 Other directives
1390 .undef variable ...
1391 Un-define the specified global variables. Only global variables
1392 can be un-defined.
1393
1395 Comments begin with a hash (‘#’) character, anywhere but in a shell com‐
1396 mand line, and continue to the end of an unescaped new line.
1397
1399 .EXEC Target is never out of date, but always execute commands any‐
1400 way.
1401 .IGNORE Ignore any errors from the commands associated with this tar‐
1403 get, exactly as if they all were preceded by a dash (‘-’).
1404 .MADE Mark all sources of this target as being up to date.
1406 .MAKE Execute the commands associated with this target even if the -n
1408 or -t options were specified. Normally used to mark recursive
1409 bmakes.
1410 .META Create a meta file for the target, even if it is flagged as
1412 .PHONY, .MAKE, or .SPECIAL. Usage in conjunction with .MAKE is
1413 the most likely case. In “meta” mode, the target is out-of-
1414 date if the meta file is missing.
1415 .NOMETA Do not create a meta file for the target. Meta files are also
1417 not created for .PHONY, .MAKE, or .SPECIAL targets.
1418 .NOMETA_CMP
1420 Ignore differences in commands when deciding if target is out
1421 of date. This is useful if the command contains a value which
1422 always changes. If the number of commands change, though, the
1423 target is still considered out of date. The same effect ap‐
1424 plies to any command line that uses the variable .OODATE, which
1425 can be used for that purpose even when not otherwise needed or
1426 desired:
1427 skip-compare-for-some:
1430 @echo this is compared
1431 @echo this is not ${.OODATE:M.NOMETA_CMP}
1432 @echo this is also compared
1433 The :M pattern suppresses any expansion of the unwanted vari‐
1435 able.
1436 .NOPATH Do not search for the target in the directories specified by
1438 .PATH.
1439 .NOTMAIN Normally bmake selects the first target it encounters as the
1441 default target to be built if no target was specified. This
1442 source prevents this target from being selected.
1443 .OPTIONAL
1445 If a target is marked with this attribute and bmake can't fig‐
1446 ure out how to create it, it ignores this fact and assumes the
1447 file isn't needed or already exists.
1448 .PHONY The target does not correspond to an actual file; it is always
1450 considered to be out of date, and is not created with the -t
1451 option. Suffix-transformation rules are not applied to .PHONY
1452 targets.
1453 .PRECIOUS
1455 When bmake is interrupted, it normally removes any partially
1456 made targets. This source prevents the target from being re‐
1457 moved.
1458 .RECURSIVE
1460 Synonym for .MAKE.
1461 .SILENT Do not echo any of the commands associated with this target,
1463 exactly as if they all were preceded by an at sign (‘@’).
1464 .USE Turn the target into bmake's version of a macro. When the tar‐
1466 get is used as a source for another target, the other target
1467 acquires the commands, sources, and attributes (except for
1468 .USE) of the source. If the target already has commands, the
1469 .USE target's commands are appended to them.
1470 .USEBEFORE
1472 Like .USE, but instead of appending, prepend the .USEBEFORE
1473 target commands to the target.
1474 .WAIT If .WAIT appears in a dependency line, the sources that precede
1476 it are made before the sources that succeed it in the line.
1477 Since the dependents of files are not made until the file it‐
1478 self could be made, this also stops the dependents being built
1479 unless they are needed for another branch of the dependency
1480 tree. So given:
1481 x: a .WAIT b
1483 echo x
1484 a:
1485 echo a
1486 b: b1
1487 echo b
1488 b1:
1489 echo b1
1490 the output is always ‘a’, ‘b1’, ‘b’, ‘x’.
1492 The ordering imposed by .WAIT is only relevant for parallel
1494 makes.
1495
1497 Special targets may not be included with other targets, i.e. they must be
1498 the only target specified.
1499 .BEGIN Any command lines attached to this target are executed before
1501 anything else is done.
1502 .DEFAULT
1504 This is sort of a .USE rule for any target (that was used only
1505 as a source) that bmake can't figure out any other way to cre‐
1506 ate. Only the shell script is used. The .IMPSRC variable of a
1507 target that inherits .DEFAULT's commands is set to the target's
1508 own name.
1509 .DELETE_ON_ERROR
1511 If this target is present in the makefile, it globally causes
1512 make to delete targets whose commands fail. (By default, only
1513 targets whose commands are interrupted during execution are
1514 deleted. This is the historical behavior.) This setting can be
1515 used to help prevent half-finished or malformed targets from be‐
1516 ing left around and corrupting future rebuilds.
1517 .END Any command lines attached to this target are executed after ev‐
1519 erything else is done successfully.
1520 .ERROR Any command lines attached to this target are executed when an‐
1522 other target fails. The .ERROR_TARGET variable is set to the
1523 target that failed. See also MAKE_PRINT_VAR_ON_ERROR.
1524 .IGNORE Mark each of the sources with the .IGNORE attribute. If no
1526 sources are specified, this is the equivalent of specifying the
1527 -i option.
1528 .INTERRUPT
1530 If bmake is interrupted, the commands for this target are exe‐
1531 cuted.
1532 .MAIN If no target is specified when bmake is invoked, this target is
1534 built.
1535 .MAKEFLAGS
1537 This target provides a way to specify flags for bmake at the
1538 time when the makefiles are read. The flags are as if typed to
1539 the shell, though the -f option has no effect.
1540 .NOPATH Apply the .NOPATH attribute to any specified sources.
1542 .NOTPARALLEL
1544 Disable parallel mode.
1545 .NO_PARALLEL
1547 Synonym for .NOTPARALLEL, for compatibility with other pmake
1548 variants.
1549 .NOREADONLY
1551 clear the read-only attribute from the global variables speci‐
1552 fied as sources.
1553 .OBJDIR The source is a new value for ‘.OBJDIR’. If it exists, bmake
1555 changes the current working directory to it and updates the
1556 value of ‘.OBJDIR’.
1557 .ORDER In parallel mode, the named targets are made in sequence. This
1559 ordering does not add targets to the list of targets to be made.
1560 Since the dependents of a target do not get built until the tar‐
1562 get itself could be built, unless ‘a’ is built by another part
1563 of the dependency graph, the following is a dependency loop:
1564 .ORDER: b a
1566 b: a
1567 .PATH The sources are directories which are to be searched for files
1569 not found in the current directory. If no sources are speci‐
1570 fied, any previously specified directories are removed from the
1571 search path. If the source is the special .DOTLAST target, the
1572 current working directory is searched last.
1573 .PATH.suffix
1575 Like .PATH but applies only to files with a particular suffix.
1576 The suffix must have been previously declared with .SUFFIXES.
1577 .PHONY Apply the .PHONY attribute to any specified sources.
1579 .POSIX If this is the first non-comment line in the main makefile, the
1581 variable %POSIX is set to the value ‘1003.2’ and the makefile
1582 ‘<posix.mk>’ is included if it exists, to provide POSIX-compati‐
1583 ble default rules. If bmake is run with the -r flag, only
1584 ‘posix.mk’ contributes to the default rules.
1585 .PRECIOUS
1587 Apply the .PRECIOUS attribute to any specified sources. If no
1588 sources are specified, the .PRECIOUS attribute is applied to ev‐
1589 ery target in the file.
1590 .READONLY
1592 set the read-only attribute on the global variables specified as
1593 sources.
1594 .SHELL Sets the shell that bmake uses to execute commands in jobs mode.
1596 The sources are a set of field=value pairs.
1597 name This is the minimal specification, used to select
1599 one of the built-in shell specs; sh, ksh, and csh.
1600 path Specifies the absolute path to the shell.
1602 hasErrCtl Indicates whether the shell supports exit on error.
1604 check The command to turn on error checking.
1606 ignore The command to disable error checking.
1608 echo The command to turn on echoing of commands executed.
1610 quiet The command to turn off echoing of commands exe‐
1612 cuted.
1613 filter The output to filter after issuing the quiet com‐
1615 mand. It is typically identical to quiet.
1616 errFlag The flag to pass the shell to enable error checking.
1618 echoFlag The flag to pass the shell to enable command echo‐
1620 ing.
1621 newline The string literal to pass the shell that results in
1623 a single newline character when used outside of any
1624 quoting characters.
1625 Example:
1626 .SHELL: name=ksh path=/bin/ksh hasErrCtl=true \
1628 check="set -e" ignore="set +e" \
1629 echo="set -v" quiet="set +v" filter="set +v" \
1630 echoFlag=v errFlag=e newline="'\n'"
1631 .SILENT Apply the .SILENT attribute to any specified sources. If no
1633 sources are specified, the .SILENT attribute is applied to every
1634 command in the file.
1635 .STALE This target gets run when a dependency file contains stale en‐
1637 tries, having .ALLSRC set to the name of that dependency file.
1638 .SUFFIXES
1640 Each source specifies a suffix to bmake. If no sources are
1641 specified, any previously specified suffixes are deleted. It
1642 allows the creation of suffix-transformation rules.
1643 Example:
1645 .SUFFIXES: .c .o
1647 .c.o:
1648 cc -o ${.TARGET} -c ${.IMPSRC}
1649 .SYSPATH
1651 The sources are directories which are to be added to the system
1652 include path which bmake searches for makefiles. If no sources
1653 are specified, any previously specified directories are removed
1654 from the system include path.
1655
1657 bmake uses the following environment variables, if they exist: MACHINE,
1658 MACHINE_ARCH, MAKE, MAKEFLAGS, MAKEOBJDIR, MAKEOBJDIRPREFIX, MAKESYSPATH,
1659 PWD, and TMPDIR.
1660 MAKEOBJDIRPREFIX and MAKEOBJDIR may only be set in the environment or on
1662 the command line to bmake and not as makefile variables; see the descrip‐
1663 tion of ‘.OBJDIR’ for more details.
1664
1666 .depend list of dependencies
1667 makefile first default makefile if no makefile is specified on the
1668 command line
1669 Makefile second default makefile if no makefile is specified on the
1670 command line
1671 sys.mk system makefile
1672 /usr/share/mk system makefile directory
1673
1675 The basic make syntax is compatible between different make variants; how‐
1676 ever the special variables, variable modifiers and conditionals are not.
1677 Older versions
1679 An incomplete list of changes in older versions of bmake:
1680 The way that .for loop variables are substituted changed after NetBSD 5.0
1682 so that they still appear to be variable expansions. In particular this
1683 stops them being treated as syntax, and removes some obscure problems us‐
1684 ing them in .if statements.
1685 The way that parallel makes are scheduled changed in NetBSD 4.0 so that
1687 .ORDER and .WAIT apply recursively to the dependent nodes. The algo‐
1688 rithms used may change again in the future.
1689 Other make dialects
1691 Other make dialects (GNU make, SVR4 make, POSIX make, etc.) do not sup‐
1692 port most of the features of bmake as described in this manual. Most no‐
1693 tably:
1694 • The .WAIT and .ORDER declarations and most functionality per‐
1696 taining to parallelization. (GNU make supports parallelization
1697 but lacks the features needed to control it effectively.)
1698 • Directives, including for loops and conditionals and most of
1700 the forms of include files. (GNU make has its own incompatible
1701 and less powerful syntax for conditionals.)
1702 • All built-in variables that begin with a dot.
1704 • Most of the special sources and targets that begin with a dot,
1706 with the notable exception of .PHONY, .PRECIOUS, and .SUFFIXES.
1707 • Variable modifiers, except for the ‘:old=new’ string substitu‐
1709 tion, which does not portably support globbing with ‘%’ and
1710 historically only works on declared suffixes.
1711 • The $> variable even in its short form; most makes support this
1713 functionality but its name varies.
1714 Some features are somewhat more portable, such as assignment with +=, ?=,
1716 and !=. The .PATH functionality is based on an older feature VPATH found
1717 in GNU make and many versions of SVR4 make; however, historically its be‐
1718 havior is too ill-defined (and too buggy) to rely upon.
1719 The $@ and $< variables are more or less universally portable, as is the
1721 $(MAKE) variable. Basic use of suffix rules (for files only in the cur‐
1722 rent directory, not trying to chain transformations together, etc.) is
1723 also reasonably portable.
1724
1726 mkdep(1)
1727
1729 bmake is derived from NetBSD make(1). It uses autoconf to facilitate
1730 portability to other platforms.
1731 A make command appeared in Version 7 AT&T UNIX. This make implementation
1733 is based on Adam de Boor's pmake program, which was written for Sprite at
1734 Berkeley. It was designed to be a parallel distributed make running jobs
1735 on different machines using a daemon called “customs”.
1736 Historically the target/dependency FRC has been used to FoRCe rebuilding
1738 (since the target/dependency does not exist ... unless someone creates an
1739 FRC file).
1740
1742 The make syntax is difficult to parse. For instance, finding the end of
1743 a variable's use should involve scanning each of the modifiers, using the
1744 correct terminator for each field. In many places make just counts {}
1745 and () in order to find the end of a variable expansion.
1746 There is no way of escaping a space character in a filename.
1748 In jobs mode, when a target fails; make will put an error token into the
1750 job token pool. This will cause all other instances of make using that
1751 token pool to abort the build and exit with error code 6. Sometimes the
1752 attempt to suppress a cascade of unnecessary errors, can result in a
1753 seemingly unexplained ‘*** Error code 6’
1754BSD June 28, 2023 BSD