NAME

SYNOPSIS

DESCRIPTION

 

 

-e

Environment variables override macro assignments within makefiles.

 

 

-f mk

Read file mk instead of the default makefile. If mk is ‘-’, standard input is used. Multiple makefiles may be specified, and are read in the order specified.

 

 

-i

Ignore non-zero exit of shell commands in the makefile. Equivalent to specifying ‘-’ before each command line in the makefile.

 

 

-k

Continue processing after errors are encountered, but only on those targets that do not depend on the target whose creation caused the error.

 

 

-n

Display the commands that would have been executed, but do not actually execute them.

 

 

-p

Print a dump of the target rules and variables on stdout. Do not build anything.

 

 

-q

Do not execute any commands, but exit with status 0 if the specified targets are up to date, and 1 otherwise.

 

 

-r

Do not use the built-in rules specified in the system makefile, <sys.mk>.

 

 

-S

Stop processing when an error is encountered. This is the default behavior. This is needed to negate the -k option during recursive builds.

 

 

-s

Do not echo commands as they are executed. Equivalent to specifying ‘@’ before each command line in the makefile.

 

 

-t

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, a bit like touch(1).

 

 

NAME=value

Set the value of the variable NAME to value.

 

 

-B

Try to be backwards compatible by executing the commands to make the prerequisites in a target rule in sequence. This is the default, in the absence of -j max_processes.

 

 

-C directory

Enter directory before doing anything.

 

 

-D variable

Define variable to be 1.

 

 

-d flags

Turn on debugging, and specify which portions of make are to print debugging information. flags is one or more of the following:

 

 

A

Print all possible debugging information; equivalent to specifying all of the debugging flags.

 

 

a

Print debugging information about archive searching and caching.

 

 

c

Print debugging information about conditional evaluation.

 

 

d

Print debugging information about directory searching and caching.

 

 

D

Print warning messages about multiply defined command lists.

 

 

e

Print debugging information about expensive command heuristics.

 

 

f

Print debugging information about the expansion of for loops.

 

 

g1

Print the input graph before making anything.

 

 

g2

Print the input graph after making everything, or before exiting on error.

 

 

h

Print information about jobs being held back because of sibling/target groups races.

 

 

j

Print debugging information about forking processes to run commands.

 

 

k

Print debugging information about manually killing processes.

 

 

l

Print commands in Makefile targets regardless of whether or not they are prefixed by @. Also known as loud behavior.

 

 

m

Print debugging information about making targets, including modification dates.

 

 

n

Print debugging information about target names equivalence computations.

 

 

p

Help finding concurrency issues for parallel make by adding some randomization. If RANDOM_ORDER is defined, targets will be shuffled before being built. If RANDOM_DELAY is defined, make will wait between 0 and ${RANDOM_DELAY} seconds before starting a command. A given random seed can be forced by setting RANDOM_SEED, but this does not guarantee reproducibility.

 

 

q

‘quick death’ option: after a fatal error, instead of waiting for other jobs to die, kill them right away.

 

 

s

Print debugging information about inference (suffix) transformation rules.

 

 

t

Print debugging information about target list maintenance.

 

 

T

Print debugging information about target group determination.

 

 

v

Print debugging information about variable assignment.

 

 

-I directory

Specify a directory in which to search for makefiles and for "..."-style inclusions. Multiple directories can be added to form a search path. Furthermore, the system include path (see the -m option) will be used after this search path.

 

 

-j max_processes

Specify the maximum number of processes that make may have running at any one time.

 

 

-m directory

Specify a directory in which to search for system include files: sys.mk and <...>-style inclusions. Multiple directories can be added to form the system search path. Using -m will override the default system include directory /usr/share/mk.

 

 

-V variable

Print make's idea of the value of variable. Do not build any targets. Multiple instances of this option may be specified; the variables will be printed one per line, with a blank line for each null or undefined variable.

DEPENDENCY LINES

 

 

:

A target is considered out of date if any of its prerequisites has been modified more recently than the target (that is, its modification time is less than that of any of its prerequisites). Thus, targets with no prerequisites are always out of date.

make will then execute the list of shell commands associated with that target.

Additional prerequisites may be specified over additional dependency lines: make will consider all prerequisites for determining out-of-date status. The target is removed if make is interrupted.

 

 

!

make first examines all prerequisites and re-creates them as necessary.

It will then always execute the list of shell commands associated with that target (as if the target always was out of date).

Like :, additional prerequisites may be specified over additional dependency lines, and the target is still removed if make is interrupted.

 

 

::

Each dependency line for a target is considered independently. A target is considered out of date for this target rule if any of its prerequisites in this dependency has been modified more recently than the target.

make will then execute the list of shell commands associated with that target. Target rules that specify no prerequisites are always executed.

The target will not be removed if make is interrupted.

target1 target2: reqa reqa 
	cmd1 
	cmd2

target1: reqa reqa 
	cmd1 
	cmd2 
target2: reqa reqa 
	cmd1 
	cmd2

SHELL COMMANDS

 

 

‘@’

causes the command not to be echoed before it is executed.

 

 

‘-’

causes any non-zero exit status of the command line to be ignored.

 

 

‘+’

causes the command to be executed even if -n has been specified. (This can be useful to debug recursive Makefiles.)

INFERENCE RULES

.SUFFIXES: .c .o 
.c.o: 
	${CC} ${CFLAGS} -c $< 
 
prog: a.o b.o 
	${CC} ${CFLAGS} -o $@ a.o 
 
a.o b.o: a.h 
 
b.o: b.c 
	${CC} -DFOO ${CFLAGS} -o $@ $<

VARIABLE ASSIGNMENTS

 

 

=

Assign the value to the variable. Any previous value is overridden.

 

 

:=

Assign with expansion, i.e., expand the value before assigning it to the variable (extension).

 

 

+=

Append the value to the current value of the variable (extension).

 

 

?=

Assign the value to the variable if it is not already defined (BSD extension). Normally, expansion is not done until the variable is referenced.

 

 

!=

Perform variable expansion and pass the result to the shell for execution on the spot, assigning the result to the variable. Any newlines in the result are also replaced with spaces (BSD extension).

 

 

!!=

Perform variable expansion on the spot and pass the result to the shell for execution only when the value is needed, assigning the result to the variable.

This is almost identical to != except that a shell is only run when the variable value is needed. Any newlines in the result are also replaced with spaces (OpenBSD extension).

A ?!= cmd

A +!!= cmd

 

 

Environment variables

Variables defined as part of make's environment.

 

 

Global variables

Variables defined in the makefile or in included makefiles.

 

 

Command line variables

Variables defined as part of the command line.

 

 

Local variables

Variables that are defined specific to a certain target. Standard local variables are as follows:

 

 

@

The name of the target.

 

 

%

The name of the archive member (only valid for library rules).

 

 

!

The name of the archive file (only valid for library rules).

 

 

?

The list of prerequisites for this target that were deemed out of date.

 

 

<

The name of the prerequisite from which this target is to be built, if a valid inference rule (suffix rule) is in scope.

 

 

*

The file prefix of the file, containing only the file portion, no suffix or preceding directory components.

The six variables ‘@F’, ‘@D’, ‘<F’, ‘<D’, ‘*F’, and ‘*D’ yield the “filename” and “directory” parts of the corresponding macros.

For maximum compatibility, ‘<’ should only be used for actual inference rules. It is also set for normal target rules when there is an inference rule that matches the current target and prerequisite in scope. That is, in

.SUFFIXES: .c .o 
file.o: file.c 
	cmd1 $< 
 
.c.o: 
	cmd2
    

building file.o will execute “cmd1 file.c”.

As an extension, make supports the following local variables:

 

 

>

The list of all prerequisites for this target.

 

 

.ALLSRC

Synonym for ‘>’.

 

 

.ARCHIVE

Synonym for ‘!’.

 

 

.IMPSRC

Synonym for ‘<’.

 

 

.MEMBER

Synonym for ‘%’.

 

 

.OODATE

Synonym for ‘?’.

 

 

.PREFIX

Synonym for ‘*’.

 

 

.TARGET

Synonym for ‘@’.

These variables may be used on the dependency half of dependency lines, when they make sense.

 

 

$

A single dollar sign ‘$’, i.e., ‘$$’ expands to a single dollar sign.

 

 

.MAKE

The name that make was executed with (argv[0]).

 

 

.CURDIR

A path to the directory where make was executed.

 

 

.OBJDIR

Path to the directory where targets are built. At startup, make searches for an alternate directory to place target files. make tries to chdir(2) into MAKEOBJDIR (or obj if MAKEOBJDIR is not defined), and sets .OBJDIR accordingly. Should that fail, .OBJDIR is set to .CURDIR.

 

 

MAKEFILE_LIST

The list of files read by make.

 

 

.MAKEFLAGS

The environment variable MAKEFLAGS may contain anything that may be specified on make's command line. Its contents are stored in make's .MAKEFLAGS variable. Anything specified on make's command line is appended to the .MAKEFLAGS variable which is then entered into the environment as MAKEFLAGS for all programs which make executes.

 

 

MFLAGS

A shorter synonym for .MAKEFLAGS.

 

 

PWD

Alternate path to the current directory. make normally sets ‘.CURDIR’ to the canonical path given by getcwd(3). However, if the environment variable PWD is set and gives a path to the current directory, then make sets ‘.CURDIR’ to the value of PWD instead. PWD is always set to the value of ‘.OBJDIR’ for all programs which make executes.

 

 

.TARGETS

List of targets make is currently building.

 

 

MACHINE

Name of the machine architecture make is running on, obtained from the MACHINE environment variable, or through uname(3) if not defined.

 

 

MACHINE_ARCH

Name of the machine architecture make was compiled for, obtained from the MACHINE_ARCH environment variable, or defined at compilation time.

 

 

MACHINE_CPU

Name of the machine processor make was compiled for, obtained from the MACHINE_CPU environment variable, or defined at compilation time. On processors where only one endianness is possible, the value of this variable is always the same as MACHINE_ARCH.

 

 

MAKEFILE

Possibly the file name of the last makefile that has been read. It should not be used; see the BUGS section below.

 

 

:E

Replaces each word in the variable with its suffix.

 

 

:H

Replaces each word in the variable with everything but the last component.

 

 

:L

Replaces each word in the variable with its lower case equivalent.

 

 

:U

Replaces each word in the variable with its upper case equivalent.

 

 

:Mpattern

Select only those words that match the rest of the modifier. The standard shell wildcard characters (‘*’, ‘?’, and ‘[]’) may be used. The wildcard characters may be escaped with a backslash (‘\’).

 

 

:Npattern

This is identical to :M, but selects all words which do not match the rest of the modifier.

 

 

:Q

Quotes every shell meta-character in the variable, so that it can be passed safely through recursive invocations of make.

 

 

:QL

Quote list: quotes every shell meta-character in the variable, except whitespace, so that it can be passed to a shell's ‘for’ loops.

 

 

:R

Replaces each word in the variable with everything but its suffix.

 

 

:S/old_string/new_string/[1g]

Modify the first occurrence of old_string in the variable's value, replacing it with new_string. If a ‘g’ is appended to the last slash of the pattern, all occurrences in each word are replaced. If a ‘1’ is appended to the last slash of the pattern, only the first word is affected. If old_string begins with a caret (‘^’), old_string is anchored at the beginning of each word. If old_string ends with a dollar sign (‘$’), it is anchored at the end of each word. Inside new_string, an ampersand (‘&’) is replaced by old_string (without any ‘^’ or ‘$’). Any character may be used as a delimiter for the parts of the modifier string. The anchoring, ampersand and delimiter characters may be escaped with a backslash (‘\’).

Variable expansion occurs in the normal fashion inside both old_string and new_string with the single exception that a backslash is used to prevent the expansion of a dollar sign (‘$’), not a preceding dollar sign as is usual.

 

 

:C/pattern/replacement/[1g]

The :C modifier is just like the :S modifier except that the old and new strings, instead of being simple strings, are an extended regular expression (see re_format(7)) and an ed(1)-style replacement string. Normally, the first occurrence of the pattern in each word of the value is changed. The ‘1’ modifier causes the substitution to apply to at most one word; the ‘g’ modifier causes the substitution to apply to as many instances of the search pattern as occur in the word or words it is found in. Note that ‘1’ and ‘g’ are orthogonal; the former specifies whether multiple words are potentially affected, the latter whether multiple substitutions can potentially occur within each affected word.

 

 

:T

Replaces each word in the variable with its last component.

 

 

:old_string=new_string

This is the AT&T System V UNIX style variable substitution. It must be the last modifier specified. If old_string or new_string do not contain the pattern matching character ‘%’ then it is assumed that they are anchored at the end of each word, so only suffixes or entire words may be replaced. Otherwise ‘%’ is the substring of old_string to be replaced in new_string. The right hand side (new_string) may contain variable values, which will be expanded. To put an actual single dollar, just double it.

INCLUDE STATEMENTS, CONDITIONALS AND FOR LOOPS

.include <file>

.   include <file>

 

 

.undef variable

Un-define the specified global variable. Only global variables may be un-defined.

 

 

.poison variable

Poison the specified global variable. Any further reference to variable will be flagged as an error.

 

 

.poison !defined (variable)

It is an error to try to use the value of variable in a context where it is not defined.

 

 

.poison empty (variable)

It is an error to try to use the value of variable in a context where it is not defined or empty.

 

 

.if [!]expression [operator expression ...]

Test the value of an expression.

 

 

.ifdef [!]variable [operator variable ...]

Test the value of a variable.

 

 

.ifndef [!]variable [operator variable ...]

Test the value of a variable.

 

 

.ifmake [!]target [operator target ...]

Test the target being built.

 

 

.ifnmake [!] target [operator target ...]

Test the target being built.

 

 

.else

Reverse the sense of the last conditional.

 

 

.elif [!] expression [operator expression ...]

A combination of ‘.else’ followed by ‘.if’.

 

 

.elifdef [!]variable [operator variable ...]

A combination of ‘.else’ followed by ‘.ifdef’.

 

 

.elifndef [!]variable [operator variable ...]

A combination of ‘.else’ followed by ‘.ifndef’.

 

 

.elifmake [!]target [operator target ...]

A combination of ‘.else’ followed by ‘.ifmake’.

 

 

.elifnmake [!]target [operator target ...]

A combination of ‘.else’ followed by ‘.ifnmake’.

 

 

.endif

End the body of the conditional.

 

 

||

logical OR

 

 

&&

Logical AND; of higher precedence than ||.

 

 

commands

Takes a target name as an argument and evaluates to true if the target has been defined and has shell commands associated with it.

 

 

defined

Takes a variable name as an argument and evaluates to true if the variable has been defined.

 

 

make

Takes a target name as an argument and evaluates to true if the target was specified as part of make's command line or was declared the default target (either implicitly or explicitly, see .MAIN) before the line containing the conditional.

 

 

empty

Takes a variable, with possible modifiers, and evaluates to true if the expansion of the variable would result in an empty string.

 

 

exists

Takes a file name as an argument and evaluates to true if the file exists. The file is searched for on the system search path (see .PATH).

 

 

target

Takes a target name as an argument and evaluates to true if the target has been defined.

.for variable [variable ...] in expression 
	<make-rules> 
.endfor

sinclude file 
-include file

COMMENTS

TARGET ATTRIBUTES

 

 

“Always build”

Run the commands associated with this target even if the -n or -t options were specified. Can be used to mark recursive make's, but prefer standard ‘+cmd’.

 

 

“Cheap”

In parallel mode, don't scan the commands for occurrences of make, thus letting normal recursive -j behavior apply.

 

 

“Expensive”

In parallel mode, assume commands will invoke recursive commands. Once make starts building an expensive target, it won't start building anything else until that target has finished building.

 

 

“Ignoring errors”

Ignore any errors generating by running shell commands, exactly as if they were all preceded by a dash (‘-’).

 

 

“Phony”

A phony target is a target that does not correspond to any object in the file system (more like a placeholder for a list of commands).

Phony targets are always out of date at the start of a run, but make still keeps track of when they are built (that is, when the associated command list finishes running).

 

 

“Precious”

Don't remove the target if make is interrupted in the middle of building it.

 

 

“Silent”

Do not display shell commands before running them, exactly as if they were all preceded by a ‘@’.

SPECIAL TARGETS

 

 

.DEFAULT

If there is a .DEFAULT target rule, with commands but no prerequisites, and make can't figure out another way to build a target, it will use that list of commands, setting < and @ appropriately.

 

 

.IGNORE

Mark its prerequisites as “Ignoring errors”.

If the list of prerequisites is empty, apply that to all targets, exactly like the -i command-line option.

 

 

.PRECIOUS

Mark its prerequisites as “Precious”.

If the list of prerequisites is empty, apply that to all targets.

 

 

.SILENT

Mark its prerequisites as “Silent”.

If the list of prerequisites is empty, apply that to all targets, exactly like the -s command-line option.

 

 

.SUFFIXES

See INFERENCE RULES.

 

 

.BEGIN

Command lines attached to this target are executed before anything else is done.

 

 

.CHEAP

Mark its prerequisites as “Cheap”.

 

 

.END

Command lines attached to this target are executed at the end of a successful run.

 

 

.EXPENSIVE

Mark its prerequisites as “Expensive”.

 

 

.INTERRUPT

Command lines attached to this target are executed if make is interrupted by a SIGINT.

 

 

.MADE

Mark its prerequisites as being up to date.

 

 

.MAKE

Mark its prerequisites as “Always build”. Prefer standard ‘+cmd’.

 

 

.MAIN

If no target is specified when make is invoked, this target will be built. This is always set, either explicitly, or implicitly when make selects the default target, to give the user a way to refer to the default target on the command line.

 

 

.MAKEFLAGS

This target provides a way to specify flags for make when the makefile is used. The flags are as if typed to the shell, though the -f option will have no effect.

 

 

.NOTPARALLEL

Disable parallel mode for the current makefile. The -j option is still passed to submakes.

 

 

.NO_PARALLEL

Same as above, for compatibility with other pmake variants.

 

 

.ORDER

The list of prerequisites should be built in sequence.

 

 

.PATH

The prerequisites define a search path: directories that will be searched for files not found in the current directory. If no prerequisites are specified, any previously specified directories are deleted.

 

 

.PATH.suffix

This target is only valid if .suffix is a currently valid suffix. The prerequisites defines a search path for files ending in that suffix. For files not found in the current directory, make will first look in that path, before reverting to the default search path.

 

 

.PHONY

Mark its prerequisites as “Phony” targets.

SPECIAL PREREQUISITES

 

 

.NOTMAIN

Normally make selects the first target it encounters as the default target to be built if no target was specified. This prerequisite prevents this target from being selected.

 

 

.OPTIONAL

If a target is marked with this attribute and make can't figure out how to create it, it will ignore this fact and assume the file isn't needed or already exists.

 

 

.USE

Turn the target into make's version of a macro. When the target is used as a prerequisite for another target, the other target acquires the commands, prerequisites, and attributes (except for .USE) of the prerequisite. If the target already has commands, the .USE target's commands are appended to them.

 

 

.WAIT

If .WAIT appears in a dependency line, the prerequisites that precede it are made before the prerequisites that follow it in the line. Loops are not detected and targets that form loops will be silently ignored.

ENVIRONMENT

FILES

.depend

list of dependencies

makefile

default makefile

Makefile

default makefile if makefile does not exist

sys.mk

system makefile

/usr/share/mk

system makefile directory

/usr/obj

default MAKEOBJDIRPREFIX directory

EXIT STATUS

SEE ALSO

STANDARDS

HISTORY

BUGS

a: 
	@echo "Executed" 
a: 
	@echo "Bad luck"

.for TMACHINE in ${SHARED_ARCHS} 
.if "${TMACHINE}" == ${MACHINE} 
     ... 
.endif 
.endfor

A=abcd;c.c 
.if ${A:R} == "abcd;c"

.for I in a b c d 
I:=${I:S/a/z/} 
A+=$I 
.endfor