Pattern matching rules.

Implicit rules, read in from a user-supplied makefile.

Standard implicit rules (also known as suffix rules), typically read in from the file /usr/share/lib/make/make.rules.

SCCS retrieval. make retrieves the most recent version from the SCCS history file (if any). See the description of the .SCCS_GET: special-function target for details.

The rule from the .DEFAULT: target entry, if there is such an entry in the makefile.

Changes the current working directory to the directory directory before attempting to open and process the Makefile or run any targets. This option may be specified more than once, each subsequent occurrence of the option is dependent on those that came before it.

Displays the reasons why make chooses to rebuild a target. make displays any and all dependencies that are newer. In addition, make displays options read in from the MAKEFLAGS environment variable.

Displays the dependency check and processing in vast detail.

Displays the text of the makefiles read in.

Displays the text of the makefiles, make.rules file, the state file, and all hidden-dependency reports.

Environment variables override assignments within makefiles.

Uses the description file makefile. A - as the makefile argument denotes the standard input. The contents of makefile, when present, override the standard set of implicit rules and predefined macros. When more than one -f makefile argument pair appears, make uses the concatenation of those files, in order of appearance. When no makefile is specified, /usr/bin/make tries the following in sequence, except when in POSIX mode (see .POSIX in Usage):

Ignores error codes returned by commands. Equivalent to the special-function target .IGNORE:.

Specify the maximum number of jobs that each instance of make will invoke.

When a nonzero error status is returned by a rule, or when make cannot find a rule, abandons work on the current target, but continues with other dependency branches that do not depend on it.

Uses the state file statefile. A - as the statefile argument denotes the standard input. The contents of statefile, when present, override the standard set of implicit rules and predefined macros. When more than one -K statefile argument pair appears, make uses the concatenation of those files, in order of appearance. (See also .KEEP_STATE and .KEEP_STATE_FILE in the Special-Function Targets section).

Specify whether make should execute jobs serially or in parallel. The default for make is to run serially unless -j is specified. The default is for dmake is to run in parallel.

No execution mode. Prints commands, but does not execute them. Even lines beginning with an @ are printed. However, if a command line contains a reference to the $(MAKE) macro, that line is always executed (see the discussion of MAKEFLAGS in Reading Makefiles and the Environment). When in POSIX mode, lines beginning with a "+" are executed.

Prints out the complete set of macro definitions and target descriptions.

Merely reports dependencies, rather than building them.

Question mode. make returns a zero or nonzero status code depending on whether or not the target file is up to date. When in POSIX mode, lines beginning with a "+" are executed.

Does not read in the default makefile /usr/share/lib/make/make.rules.

Silent mode. Does not print command lines before executing them. Equivalent to the special-function target .SILENT:.

Undoes the effect of the -k option. Stops processing when a non-zero exit status is returned by a command.

Touches the target files (bringing them up to date) rather than performing their rules. Warning: This can be dangerous when files are maintained by more than one person. When the .KEEP_STATE: target appears in the makefile, this option updates the state file just as if the rules had been performed. When in POSIX mode, lines beginning with a "+" are executed.

Puts make into SysV mode. Refer to sysV-make(1) for respective details.

Prints "Entering directory" and "Leaving directory" messages including the name of the current working directory and the current make nesting level before starting and after completing a build. Useful for finding the source file responsible for a compilation error within a hierarchy of makefiles.

Target names, as defined in Usage.

Macro definition. This definition overrides any regular definition for the specified macro within the makefile itself, or in the environment. However, this definition can still be overridden by conditional macro assignments.

Start a comment. The comment ends at the next NEWLINE. If the # follows the TAB in a command line, that line is passed to the shell (which also treats # as the start of a comment).

If the word include appears as the first seven letters of a line and is followed by a SPACE or TAB, the string that follows is taken as a filename to interpolate at that line. include files can be nested to a depth of no more than 38 nested makefiles. If filename is a macro reference, it is expanded.

Target list terminator. Words following the colon are added to the dependency list for the target or targets. If a target is named in more than one colon-terminated target entry, the dependencies for all its entries are added to form that target's complete dependency list.

Target terminator for alternate dependencies. When used in place of a : the double-colon allows a target to be checked and updated with respect to alternate dependency lists. When the target is out-of-date with respect to dependencies listed in the first alternate, it is built according to the rule for that entry. When out-of-date with respect to dependencies in another alternate, it is built according the rule in that other entry. Implicit rules do not apply to double-colon targets; you must supply a rule for each entry. If no dependencies are specified, the rule is always performed.

Target group. The rule in the target entry builds all the indicated targets as a group. It is normally performed only once per make run, but is checked for command dependencies every time a target in the group is encountered in the dependency scan.

Pattern matching wild card metacharacter. Like the * shell wild card, % matches any string of zero or more characters in a target name or dependency, in the target portion of a conditional macro definition, or within a pattern replacement macro reference. Notice that only one % can appear in a target, dependency-name, or pattern-replacement macro reference.

make ignores the leading ./ characters from targets with names given as pathnames relative to "dot," the working directory.

Macro definition. The word to the left of this character is the macro name; words to the right comprise its value. Leading and trailing white space characters are stripped from the value. A word break following the = is implied.

Macro reference. The following character, or the parenthesized or bracketed string, is interpreted as a macro reference: make expands the reference (including the $) by replacing it with the macro's value.

Macro-reference name delimiters. A parenthesized or bracketed word appended to a $ is taken as the name of the macro being referred to. Without the delimiters, make recognizes only the first character as the macro name.

A reference to the dollar-sign macro, the value of which is the character $. Used to pass variable expressions beginning with $ to the shell, to refer to environment variables which are expanded by the shell, or to delay processing of dynamic macros within the dependency list of a target, until that target is actually processed.

Escaped dollar-sign character. Interpreted as a literal dollar sign within a rule.

When used in place of =, appends a string to a macro definition (must be surrounded by white space, unlike =).

Conditional macro assignment. When preceded by a list of targets with explicit target entries, the macro definition that follows takes effect when processing only those targets, and their dependencies.

Define the value of a macro to be the output of a command (see Command Substitutions below).

In a macro reference, execute the command stored in the macro, and replace the reference with the output of that command (see Command Substitutions below).

make always executes the commands preceded by a "+", even when -n is specified.

make ignores any nonzero error code returned by a command line for which the first non-TAB character is a -. This character is not passed to the shell as part of the command line. make normally terminates when a command returns nonzero status, unless the -i or -k options, or the .IGNORE: special-function target is in effect.

If the first non-TAB character is a @, make does not print the command line before executing it. This character is not passed to the shell.

Escape command-dependency checking. Command lines starting with this character are not subject to command dependency checking.

Force command-dependency checking. Command-dependency checking is applied to command lines for which it would otherwise be suppressed. This checking is normally suppressed for lines that contain references to the ? dynamic macro (for example, $?). When any combination of +, -, @, ?, or ! appear as the first characters after the TAB, all that are present apply. None are passed to the shell.

If it has an entry in the makefile, the rule for this target is used to process a target when there is no other entry for it, no rule for building it, and no SCCS history file from which to retrieve a current version. make ignores any dependencies for this target.

If defined in the makefile, make processes this target and its dependencies after all other targets are built. This target is also performed when make halts with an error, unless the .FAILED target is defined.

This target, along with its dependencies, is performed instead of .DONE when defined in the makefile and make halts with an error.

This target contains the rule for retrieving the current version of an SCCS file from its history file in the current working directory. make uses this rule when it is running in POSIX mode.

Ignore errors. When this target appears in the makefile, make ignores non-zero error codes returned from commands. When used in POSIX mode, .IGNORE could be followed by target names only, for which the errors is ignored.

If defined in the makefile, this target and its dependencies are built before any other targets are processed.

If this target is in effect, make updates the state file, .make.state, in the current directory. This target also activates command dependencies, and hidden dependency checks. If either the .KEEP_STATE: target appears in the makefile, or the environment variable KEEP_STATE is set (setenv KEEP_STATE), make rebuilds everything in order to collect dependency information, even if all the targets were up to date due to previous make runs. See also the Environment Variables section. This target has no effect if used in POSIX mode.

This target has no effect if used in POSIX mode. This target implies .KEEP_STATE. If the target is followed by a filename, make uses it as the state file. If the target is followed by a directory name, make looks for a .make.state file in that directory. If the target is not followed by any name, make looks for .make.state file in the current working directory.

A target-entry of the form:

.MAKE_VERSION: VERSION-number

Dependencies of this target will be executed serially.

Dependencies of this target will be executed in parallel.

This target enables POSIX mode.

List of files not to delete. make does not remove any of the files listed as dependencies for this target when interrupted. make normally removes the current target when it receives an interrupt. When used in POSIX mode, if the target is not followed by a list of files, all the file are assumed precious.

This target contains the rule for retrieving the current version of an SCCS file from its history file. To suppress automatic retrieval, add an entry for this target with an empty rule to your makefile.

This target contains the rule for retrieving the current version of an SCCS file from its history file. make uses this rule when it is running in POSIX mode.

Run silently. When this target appears in the makefile, make does not echo commands before executing them. When used in POSIX mode, it could be followed by target names, and only those are executed silently.

The suffixes list for selecting implicit rules (see The Suffixes List).

In a dependency list, wait until any dependency preceding this has completed before moving on to any dependency following it.

The processor type of the host system. By default, this is the output of the mach(1) command, prepended with -. Under normal circumstances, this value should never be altered by the user.

The machine architecture of the host system. By default, this is the output of the arch(1) command, prepended with -. Under normal circumstances, this value should never be altered by the user.

The processor type of the target system. By default, the output of mach, prepended with -.

The basename of the current target, derived as if selected for use with an implicit rule.

The name of a dependency file, derived as if selected for use with an implicit rule.

The name of the current target. This is the only dynamic macro whose value is strictly determined when used in a dependency list. (In which case it takes the form $$@.)

The list of dependencies that are newer than the target. Command-dependency checking is automatically suppressed for lines that contain this macro, just as if the command had been prefixed with a ?. See the description of ?, under Special Character Rules above. You can force this check with the ! command-line prefix.

The name of the library member being processed. (See Library Maintenance below.)

The maximum number of jobs that each instance of make should run.

If YES adjust the maximum number of jobs each instance of make runs based on system load. If NO do not

Adjusts the format of output from make when executing jobs in parallel. If the value is TEXT1 make will print the hostname and the command executed once when the job begins, and again preceding any output from that job. If the value is TEXT2 make will only print the command and its output only once, when execution is complete.

Specify whether jobs should be executed in serial, or parallel. Equivalent to passing the -m option.

This environment variable has the same effect as the .KEEP_STATE: special-function target. It enables command dependencies, hidden dependencies and writing of the state file.

This environment variable causes make to invoke the generic System V version of make (/usr/lib/svr4.make). See sysV-make(1).

This variable is interpreted as a character string representing a series of option characters to be used as the default options. The implementation accepts both of the following formats (but need not accept them when intermixed):

Provides a directory to be used to search for SCCS files not found in the current directory. In all of the following cases, the search for SCCS files is made in the directory SCCS in the identified directory. If the value of PROJECTDIR begins with a slash, it shall be considered an absolute pathname. Otherwise, the value of PROJECTDIR is treated as a user name and that user's initial working directory shall be examined for a subdirectory src or source. If such a directory is found, it shall be used. Otherwise, the value is used as a relative pathname. If PROJECTDIR is not set or has a null value, the search for SCCS files shall be made in the directory SCCS in the current directory. The setting of PROJECTDIR affects all files listed in the remainder of this utility description for files with a component named SCCS.

Successful completion.

The target was not up-to-date.

An error occurred.

Successful completion

An error occurred

current version(s) of make description file

SCCS history files for the above makefile(s) in the current directory

SCCS history files for the above makefile(s)

default file for user-defined targets, macros, and implicit rules

makefile for standard implicit rules and macros (not read if make.rules is)

state file in the local directory

There is no makefile entry for target, and none of make's implicit rules apply (there is no dependency file with a suffix in the suffixes list, or the target's suffix is not in the list).

make was interrupted while building target. Rather than leaving a partially-completed version that is newer than its dependencies, make removes the file named target.

make was interrupted while building target and target was not present in the directory.

make was interrupted while building target, which was not removed for the indicated reason.

The makefile indicated in an include directive was not found or was inaccessible.

A reference to the macro being defined was found in the definition.

You used the .KEEP_STATE: target, but you do not have write permission on the state file or on a temporary version of the file written first.

The previous shell command returned a nonzero error code.

The previous shell command was aborted due to a signal. If - core dumped appears after the message, a core file was created.

Displayed only when -d is in effect, this message indicates that two or more parallel targets currently being processed depend on a target which is built differently for each by virtue of conditional macros. Since the target cannot simultaneously satisfy both dependency relationships, it is conflicted.

The -d option output is much briefer in this version. -dd now produces the equivalent voluminous output.

make attempts to derive values for the dynamic macros $*, $<, and $?, while processing explicit targets. It uses the same method as for implicit rules; in some cases this can lead either to unexpected values, or to an empty value being assigned. (Actually, this was true for earlier versions as well, even though the documentation stated otherwise.)

make no longer searches for SCCS history (s.) files.

Suffix replacement in macro references are now applied after the macro is expanded.