Nokia nmake 14 NMAKE(1)


nmake − maintain and update files


nmake [ [ option ] [ script ] [ target ] ... ]


nmake reads input makefiles and triggers shell actions to build target files that are out of date with prerequisite files. Most information used to build targets is contained in the global base rules that are augmented by user makefiles. This document describes the nmake engine; the default base rules are described in makerules(1).

Each option argument is preceded by or + and follows getopt(3) conventions, with the exception that an option may appear in any position on the command line (see Options). Each script argument is a non-option argument that contains at least one of space, tab, newline, :, =, " or \ and is read as if it were a complete, preprocessed makefile. The target arguments are made in order from left to right, overriding the default main targets defined in the makefiles (see Engine Control).

A viewpath is a virtual directory structure that is the union of corresponding directories in parallel directory structures. The roots of these structures are called nodes. nmake looks for files in the virtual directory structure by searching the corresponding directory in each node for a named file. The first file of that name found is used regardless of the time-stamp.

Viewpathing allows you to modify portions of a large product without interfering with the work of other developers on the product and without duplicating the entire product in your own directory. Viewpathing allows you to develop or modify a few modules in local directories and also have access to the rest of the modules required to build a product. And, because viewpathing works for intermediate object files as well as for source files, it saves on repeated compilations. Viewpathing is also used to separate generated files from source files which is useful for building on multiple platforms from the same source code.

The viewpath nodes are defined by setting the VPATH environment variable (see Environment) to a colon separated list of node names. The first node is also referred to as the "top" node or view level 0. The view level is incremented by 1 for each subsequent node. Only the top node is writable, other nodes are considered read only. nmake must be invoked within the top node otherwise VPATH is ignored.

are the main source of input to nmake. A makefile contains a sequence of assertions and variable assignments that describe target files and their prerequisites. All parsing is ordered from left to right, top to bottom.

At least one makefile must be specified. If no file options are present then nmake attempts to read, in order, one of Makefile or makefile. The first line of the first makefile determines the base rules context. If it is of the form

rules [ "base-rules" ]

then base-rules will be used rather than the default makerules. If "base-rules" is not specified then no base rules are used. Omitting rules is equivalent to specifying rules "makerules". The actual base rules file, which must be a compiled global makefile, is found by changing the base-rules suffix to .mo and binding the resulting name using the directories of .SOURCE.mk (see Binding). The following makefile descriptions rely on nmake engine constructs and are independent of the base rules context.

If a makefile contains cpp(1) directives then it is first passed through a modified ANSI cpp. Directives and C-style comments are treated as usual, but cpp macros are only expanded on directive lines. # preceded by zero or more space characters (space or tab) starting in column 1 is interpreted by cpp, otherwise text between # (preceded by at least one space character) and newline is treated as a comment by nmake. Blank lines are uniformly ignored.

After all the makefiles have been read in, and before any command line targets are made, the collective makefile information is automatically compiled into a single nmake object file. The next time nmake executes this object file is read in place of the makefiles. The object file is automatically regenerated whenever the makefiles or their prerequisites (.e.g., include dependencies) have changed. The nmake object file name is base.mo where base is the base name of the first non-global makefile. For better performance makefiles specified by the global option should be precompiled nmake object files. Refer to the compile option below for more information.

Variables are assigned by

variable = value

where variable may be any sequence of letters, digits, underscores and dots. Depending on the context (e.g., : dependency, operator dependency, assignment, action), subsequent appearances of $(variable) expand to value and $$(variable) expands to $(variable), otherwise $ is passed untouched. value is not expanded until $(variable) is encountered (see Variable Editing). variable := value causes value to be expanded before assigning it to variable and variable += value appends the expanded value to the current value of variable. variable == value assigns value to variable and also marks variable as a candidate implicit state variable prerequisite. variable &= value defines the hidden (auxiliary) value of variable. The auxiliary value is not saved in the statefile. The expansion of variable will include the primary and auxiliary values (see :V edit operator of Variable Editing).

Variable assignments come from many sources. The precedence order (highest to lowest) is:


Variables maintained by nmake (see Automatic Variables).


Assignments done while building targets.

command line

Assignments in command line scripts.

import variables

Colon separated environment variable names listed in the value of the MAKEIMPORT variable (see ENVIRONMENT).


Normal makefile assignments.


Variables defined in the environment (see env(1)).

global makefile

Includes base rule assignments.

Variable names containing dot cannot conflict with environment variables set by the shell; such variables are typically used by the base rules. To avoid base rule conflicts users should not define upper case variable names with dot as both the first and last character.

specify dependency relationships between targets and prerequisites and provide actions that may be executed to build targets that are out of date with their prerequisites. An individual assertion is a list of target atoms, a dependency operator (see Assertion Operators), and an ordered list of prerequisite atoms for the targets. Subsequent lines with an indentation level greater than the first target comprise the action. The target list, the prerequisite list and the action may be empty. Variables in the target and prerequisite lists are expanded when the assertion is read, whereas variables in the action are not expanded until the action is executed. For portability only tab characters should be used for action indentation.

A single assertion with multiple targets associates the prerequisite list and action with the targets as if each target were in a separate assertion. Single assertions are more efficient in that the storage used by the action is shared among the targets.

An atom may appear as a target in more than one assertion. Prerequisites from successive assertions are simply appended to the prerequisite list of the target, with the exception that duplicate prerequisites are deleted (from the right) at assertion time. Only one action may be specified per target. The collection of all assertions for a given target is called the rule for that target. Atom names containing the special characters :, #, = and + must be enclosed in double quotes. For example:

target : ":file1" file2

In the process of making a target atom nmake binds the atom to either a file, a virtual atom or a state variable. This binding remains in effect for the entire nmake execution.

A state variable is an atom associated with an nmake variable that holds the variable value and the time the variable last changed. This information is retained in the statefile base.ms where base is the base name of the first makefile. Statefiles are automatically generated and loaded using the nmake object file algorithms. The state variable atom for the nmake variable variable is (variable). For example:

x.o : (DEBUG)

specifies that x.o depends on the definition of the variable DEBUG. The contents of the statefile can be listed by executing

nmake −f base.ms −blr

Atoms are bound to files using the prerequisites of the special .SOURCE and .SOURCE.pattern atoms (see Special Atoms). The prerequisites of these atoms are ordered lists of directories to be scanned when searching for files.

A virtual atom binds neither to a file nor to a state variable. Virtual atoms are declared using the .VIRTUAL attribute. Virtual atom times are retained in the statefile.

Make Algorithm
The steps taken to make a target atom are:
bind the atom

An atom retains its binding until nmake exits unless it is explicitly unbound.

check if atom already made

No work required for atoms that have already been made. If atom is active (action executing) then block until its action completes before returning.

check statefile consistency

The current time, prerequisites and action are compared with those recorded in the statefile. Any differences force the target to be rebuilt. Notice that this type of rebuild may result in empty $(>) expansions in non-metarule actions.

check .INSERT and .APPEND

Target prerequisites are modified according to these special atoms.

make explicit prerequisites

The explicit prerequisites are (recursively) made from left to right. The most recent prerequisite time is saved.

make implicit prerequisites

If the target has no explicit action and no explicit prerequisites and a metarule can be applied to generate the target then the metarule prerequisites are (recursively) made from left to right. Again the most recent prerequisite time is saved.

check if out of date

If the most recent prerequisite is newer than the target or if the target information is not consistent with the statefile then the target action is triggered to build the target.

make scan prerequisites

If the target atom is a file with a .SCAN.x attribute (see Special Atoms) then the scan prerequisites are (recursively) made from left to right. The scan prerequisites are determined either from the statefile information (if consistent) or by reading the contents of the file using scan strategy .x. The time noted for the target atom is the most recent of its own and all (recursively) of its scan prerequisite times. The scan prerequisites are saved in the statefile to avoid scanning during the next nmake execution.

sync statefile information

When the target is built (action, if any, completed) its time, action and prerequisites are saved in the statefile in preparation for the next nmake execution.

Engine Control
The global flow of control in the nmake engine is, in order:
read the args file

The first file in $(MAKEARGS) (see ENVIRONMENT) that exists in the current directory is read and the contents are inserted into the command line argument list.

read the command line arguments

The options and command line script arguments are parsed.

read the initialization script

In addition to the variables listed in ENVIRONMENT section, the special atoms .VIEW and .SOURCE.mk are initialized.

read the base rules

Determine which base rules are to be used (either user-defined or default) by checking the first line of the first explicit makefile for the rules statement. The first explicit makefile is determined by first ckecking the command line for the −f file option. If the −f option is not found, then the first file listed in $(MAKEFILES) (see ENVIRONMENT) that exists is checked. If the rules statement is not found in that file, then the default base rules, $(MAKERULES), (see ENVIRONMENT) are used.

read the global makefiles
read the explicit makefiles

If no file options are given then the files listed in $(MAKEFILES) (see ENVIRONMENT) are used.

compile makefiles to form the nmake object file

If the nmake object file is out of date with the input makefiles then the makefiles are recompiled.

read the statefile

The statefile is loaded as an nmake object file.

initialize .ARGS

The prerequisites of .ARGS are set to the list of command line targets.

make .MAKEINIT if defined
make .INIT if defined
check .ARGS

If .ARGS has no prerequisites then append the prerequisites of .MAIN onto .ARGS.

make the prerequisites of .ARGS

This constitutes the actions requested either on the command line or in the makefile, subject to the actions of .MAKEINIT and .INIT.

make .DONE if defined

Programming Constructs
Stuctured programming constructs may appear inside .MAKE actions or outside assertions. The construct keywords must be the first word on a line. Atom names matching any of the keywords must be quoted (when the first word on a line) to avoid conflicts.

Each expression may be a combination of arithmetic and string expressions where the string expression components must be quoted. "..." strings use shell pattern matching (.e.g., "string" == "pattern") whereas ’...’ strings use string equality. Empty strings evaluate to 0 in arithmetic expressions and non-empty strings evaluate to non-zero. Expression components may also contain optional variable assignments. All computations are done using signed long integers.
level message

message is output as an nmake error message with severity level level. level may be one of:

< 0

debug trace—output only if level <= debug.






error—no exit

>= 3

error—exit with code (level−2)




The statements between eval and end are expanded an additional time. eval ... end pairs may nest to cause more than one additional expansion.


Breaks out of the for and while loops and resumes execution after the end statement.

for variable patterns ...



The statements between for and end are executed with variable assigned to the name of each atom matching one of the shell patterns. A break statement breaks out of the loop and resumes execution after the end statement.

if expression


elif expression





Nested if conditional construct.

include [ − ] path

Include the file specified by path. If is present, then the file is optionally included (no warning is generated if the file is not found).

let variable = expression

Sets the value of variable to the numeric value of expression.

local var1 var2 ...

Declares variables local to the current action.

return [ expression ]

Return from the action with results specified by expression:

If expression is omitted then return as if the action completed normally.


The action failed.


The target exists but has not been updated.


Set the target time to the value specified by expression.

set [no]name=[value]

Sets options using option-by-name format (see Options).

while expression



while loop construct. A break statement breaks out of the loop and resumes execution after the end statement.

print [options] message

Prints message to the standard output. (This is the same as error 0 message.) The options are as follows:


Adds trailing null character at the end of the output string.


Sends output to the specified file descriptor.

−f format

Specifies the output format, where format is a C printf-like format string.

−o file

Open file for writing.

+o file

Open file for appending.

−p command

Use message as standard input to command.


End the arguments.

read options variable

Reads input and assigns contents to variable. One of the following options must be specified:

Reads input from file.

−p command

Reads input from the standard output of command.

rules ["base-rules"]

Determines the base rules context. If the rules statement is specified, it must be the first line of the first makefile. It will overwrite the context of the default base rules. Omitting the rules statement is equivalent to specifying rules "makerules". The rules statement with no file name specified is a request that no base rules file is to be used.

Based on metarule patterns, nmake can infer prerequisites for files that have no explicit actions or prerequisites. The prototype metarule pattern is prefix%suffix and is matched by any string containing the non-overlapping strings prefix at the beginning and suffix at the end. % matches the remaining characters and is called the stem.

The following makefile specifies that program depends on two files a.o and b.o, and that they in turn depend on .c files and a common file header.h.

program : a.o b.o
     cc a.o b.o libx.a −lm −o program
a.o : header.h a.c
     cc −c a.c
b.o : header.h b.c
     cc −c b.c

The metarule to create a file with suffix .s2 that depends on a file (with the same base name) with suffix .s1 is %.s2 : %.s1. Any prerequisites following %.s1 are transferred to each target when the metarule is applied. For example, a metarule for making optimized .o files from .c files is

%.o : %.c (CC) (CCFLAGS)
     $(CC) $(CCFLAGS) −c −o $(<) $(>)

The $(<) variable is the current target, which is the generated .o file in this case. The $(>) variable is the primary metarule prerequisite, which is the .c source file. Note that $(>) has a different meaning in non-metarule rules (see Automatic Variables).

Notice that the .o targets also depend on the values of the CC and CCFLAGS nmake variables. If the current target is a.o then nmake infers the following from the %.o : %.c metarule:

a.o : a.c (CC) (CCFLAGS)
     cc −O −c −o a.o a.c

In this case the stem is a, $(CC) and $(CCFLAGS) expand to cc and −O, respectively.

Assuming the %.o : %.c metarule has been asserted, the example can be stated more briefly:

program : a.o b.o
     $(CC) $(*) libx.a −lm −o $(<)
a.o b.o : header.h

Metarules are applied according to the order of the patterns listed as the prerequisites of the .METARULE atom. Pattern order is significant; the first possible name for which both a file and a metarule exist is inferred.

Metarules are chained as necessary. Given the metarules %.z : %.m and %.m : %.a and the source file x.a, the target file x.z will be generated by first applying %.m : %.a to x.a to build x.m, and then applying %.z : %.m to x.m to build x.z.

Metarules with the % target pattern are called unconstrained metarules and are subject to additional constraints that control metarule chaining. unconstrained metarules with the .TERMINAL attribute are applied only when the prerequisite pattern matches an existing file. Otherwise an unconstrained metarule is applied only if there exists no other metarule (other than a unconstrained metarule) for which the target pattern matches the current target. For example

     $(CO) $(COFLAGS) $(>)

is a metarule that generates source files from RCS version files in the RCS subdirectory.

Variable Editing
Edit operators allow variable values to be tested and modified during expansion. The expansion syntax is:

$(variable[:[@]op[sep arg]]...)

The operator groups, each preceded by :, are applied in order from left to right to each space separated token in the expanded variable value. The operator groups form a token pipeline where the output (returned or selected tokens) of any operator group becomes the input for the next operator group. newline is treated as a separate token. ", and \ quote space characters, but they are considered part of the token and are not removed. If @ immediately precedes an op, then the entire value is treated as a single token for that operator. sep is usually =, but, where appropriate, some operators support != and the arithmetic comparisons <, <=, >= and >.

The expansion algorithm first expands the variable name variable to determine the value to be edited. This value and the operator expressions ([:[@]op[sep arg]]...) are then expanded before the edit operators are applied. The ultimate expansion is formed by applying each operator to each token, separating adjacent results by a single space character.

$(var1 | var2...) expands the value of the first (left to right) non-null valued variable. If the last variable name is enclosed in "" then this string is used as the value if all preceding variables have null values. The standard \ character constants are interpreted within the string.

Some operators select tokens by simply returning the token value as the result; non-selected tokens produce null (the empty string). The operators are:
[sep expression]

Selects tokens having one or more attributes or prerequisites listed in expression. The tokens are treated as atoms. In case of expression being a space or vertical bar separated list of attributes, if sep is [!]=, then atoms that [do not] have any of the listed attributes are [not] selected (see Special Atoms). Attributes defined through .ATTRIBUTE special atom may also be used. If sep is <, then the pattern association rule for the rule inferred from the input token and the pattern association rule base name specified in attribute1 of expression is returned (ex. $("stdio.h":A<.SOURCE.) would give .SOURCE.%.LCL.INCLUDE). A alone expands to the list of applicable user-defined attributes.


As stated previously, the edit operators form token pipelines. The file component edit operators (:D:B:S) are the exception to the rule; they do not form token pipelines because nmake treats the file component edit operators as a group (although separated by :). Each is applied as a single edit operation. Pathnames are partitioned into three (possibly null) components. directory includes all characters up to but not including the last /. base includes all characters after the last / up to but not including the last .. suffix includes all characters from the last . on. Multiple .’s are treated as a single . and if . is the first character after the last / and is the only . then it is included in base rather than suffix. If the pipeline result is desired, extra : must be specified (e.g., :D::B will apply :B edit operation to the result of :D edit operation). Because newlines are treated as separate tokens the :D edit operator may expand each newline as . since they appear to be a base name with no directory component. newlines may be removed using the :C/\n// edit operation.


Similar to the ed(1) substitute command. Substitutes the first occurrence of the string old with the string new in each token. A trailing G causes all occurrences of old to be substituted. <del> may be any delimiter character. C/ may be abbreviated as /.


Evaluates the complete input string as a logical, string, or integer expression.


Converts tokens where format is %[−][n][.m]c. The optional is used to left-justify. The length of the output field is given by the optional n.m, where n is the minimal field width and m is the maximum number of characters to be printed. The format type specifier c signifies the desired output type. Valid format types are:


Token value is printed in decimal format. String tokens are given the value 0.


Token value is printed in octal format. String tokens are given the value 0.


Token value is printed as a string.


Token value is printed using unsigned decimal notation. String tokens are given the value 0.


Token value is printed in hexadecimal format. String tokens are given the value 0.


Token has a string conversion applied according to the specified format:


Formats the raw explain data in a useful presentation format. See also the T=QEU operator.


Token is converted to a valid nmake identifier name; invalid characters are converted to an underscore (_).


The case of each character of the token is inverted.


Token is converted to lower case.


Token is converted to upper case.


Token is converted to a valid nmake variable name; invalid characters are converted to dot (.).


Format time output for tokens of a number of seconds since Epoch. Default format is Month_name day hours:minutes:seconds year.


User defined time format using typical UNIX date format definitions.


Selects token files that can build (generate) files that match the metarule pattern pattern using the metarules. For example, a token x.y is selected if a metarule %.s : %.y has been asserted.

H [sep][U]

Heap sorts the tokens in ascending (if sep is < or default) or descending (if sep is >) order. <= sep will give low to high numeric sort, and >= sep will give high to low numeric sort. If U is specified, the sort is unique (the duplicates are removed).


list is expanded and directory tokens in variable that also appear in the expanded value of list are selected. Each selected directory will appear at most once in the return value. The directory path names are canonicalized before comparison.


Splits long lines like xargs(1) into a number of tokens, applying optional pfx to each token.

L [sep [<pattern>]]

Each token is treated as a directory name. For each token, the list of all files in the specified directories which match the optional pattern are returned. sep may be <= or >= and is used to specify that the list should be sorted in ascending or descending order respectively. The default order is unsorted.


Selects tokens [not] matching the egrep(1) style regular expression pattern.


Selects tokens [not] matching the sh(1) file match expression pattern. Multiple patterns separated by | denotes the inclusive or of the individual patterns.


Each token is numbered by its left to right position, starting with 1. Tokens with positions satisfying the integer expression position relop n are selected. relop may be one of <, <=, =, !=, >= or >. If O is specified alone, the output is the number count of tokens, O! gives the string length of each token.


Treats the tokens as file path names and applies the path name operator op. op may be:


Returns the absolute path name for specified files.


Returns the tokens that are physically bound.


Returns the canonicalized path name. .’s and redundant /’s are removed (unless . is the only remaining character). Each .. cancels the path name component to its left (unless that component is also ..); .. ’s are moved to the front of the name. /.. forms are preserved in deference to some remote file system implementations.


For each token that is a bound atom, the directory where the atom was bound is returned.


Generates 9 character hash file name (or up to 14 character hash file name if suffix is used—takes first 5 characters in suffix if it is greater than 5 characters) for the given token.


Selects tokens which are existing files and which have the same device and inode numbers as file. If P!=I=file is used, then those tokens which are existing files and are not the same file as file are returned.


Selects tokens that are atoms bound in the level 0 [<relop>level] view. Views are defined using the .VIEW special atom. relop may be one of <, <=, =, !=, >= or >.


Returns all the views of a bound file.


Returns the first occurrence of a bound file from all the views.


Returns the pathname for the probe information file for the language specified by lang and the language processor specified in the input token. If tool is unspecified, make is assumed. path indicates an alternate directory root for the probe information file.


For each token, treated as a directory path name, a path name that leads to the (possibly relative) root of the token is returned. The return value is either . or a path name consisting of .. components.


The bound name for each token that is bound to a file within a subdirectory of its view is returned.


The unbound name for each token is returned.


Returns the view directory path name of the current directory for each token that is an atom bound to a file (see also .VIEW special atom).


Returns the view local path name for each token that is an atom bound to a file. Paths in the viewpath are canonicalized and converted to their corresponding relative local path. Paths outside the viewpath are returned unmodified. Unbound paths return null.


Returns each token that is the path name of an existing file. The tokens are not bound.


Each token is quoted for literal interpretation by sh(1).


Each token is parsed as a makefile, each in a separate context. null is returned.



The tokens are bound to atoms (unless stated otherwise) and are operated on according to type. ?return replaces the default non-null return value with the expanded value of return for selected atoms and null otherwise. return is only expanded (a second expansion: the operators have already been expanded once) if the test succeeds. If type is preceded by X, then no binding is done. type may be one of:


Returns the archive update action for each atom with the .ARCHIVE attribute. If the returned action is non-null then it must be executed for any archive that has been modified or copied before the archive is used by the compilers or loaders (e.g., ranlib(1) on BSD-based systems).


The cc(1) style definition of each token that binds to a state variable is returned. Given:

TEST = 1
SIZE = 13

$(STATEVARS:T=D) expands to -DTEST -DSIZE=13.


Similar to T=D except that the expanded definitions are name=value pairs. Given the above example, $(STATEVARS:T=E) expands to DEBUG= TEST=1 SIZE=13.


Each atom that binds to a file is selected. The bound atom name is returned.


Each atom bound to a file that has been built (generated) is selected. The bound atom name is returned.


Each input token is the name of an input file to be read. The contents of all the files are returned (including any newlines). A − following the I inhibits the expansion of variable names in the file.


Generates the parentage chain of each active token.


If the unbound value of variable is null then 1 is returned, otherwise null is returned. Does not bind the tokens.


Each input token is the name of the file to be written according to the specified mode . If no mode is specified, text overrides the contents of each file. By default, the new line separator is attached to the end of the text. This edit operator is the complement to :T=I[−]. mode may be:


Appends text.

Does not put the new line separator at the end of text.


Each atom that binds to a file and is also not a symbolic link is selected. The bound atom name is returned. If symbolic links (link(2)) are not implemented then :T=P: is equivalent to :T=F:.


Query for Existing Rule Atoms. Selects tokens that are existing rule atoms. Does not bind the tokens.


Query for Defined Variables. Selects tokens that are defined variable names. Does not bind the tokens.


Query the Explain Message. Returns the explain message, if it has been set, for each token in a useful presentation format, otherwise returns null. Typically the explain message is set for targets that have been triggered. Does not bind the tokens. See also the explain and explainlog options.


Query the Unformatted Explain Data. Returns the raw explain data, if it has been set, for each token, otherwise returns null. Same as QE but the message is returned in a compact fielded format allowing easy extraction of data using standard nmake tokenization operations. Does not bind the tokens. See also the F=%(explain)S format operator. The following example shows how to use for-loops to access each field from multiple messages where variable targets is a list of targets in the makefile:

         for msg $(targets:T=QEU)
                 print msg: $(msg)
                 for field $(msg)
                         print fld: $(field)


Each token is treated as an atom and the relative time (number of seconds since the Epoch) of each atom is returned.


Converts each atom to a new atom type specified by conv and data (null is returned when the conversion specifies an undefined atom). conv may be:


Given the internal name for a state rule, convert it to the original name.


Forces creation of a new atom. Used in conjunction with the other conversion operators.


Returns the metarule name that generates files matching the metarule pattern data from files matching the metarule pattern named by each token.


Returns the alternate prerequisite state atom.


Returns the primary state atom. This is the default when conv is omitted.


Returns the state variable atom for each token that names a variable.


The format for this operator is TrelopTatom. A comparison is done between the time associated with atom and the times associated with the atoms in the token list. The tokens whose times are relop atom are returned. relop can be <, >, =, <=, >=, or !=. If atom is not specified, it defaults to the current target. For example,


lists the prerequisites whose times are newer than the time for the current target.


Returns the atom or variable name for each state atom token.


If the unbound value of variable is non-null then 1 is returned, otherwise null is returned. Does not bind the tokens.


If a type operator is forcing a file to be bound, and the W operator is applied, do not wait for the bind to complete.


Binding should not be done. Used in conjunction with other type edit operators.


The value of variable is used without expansion. type may be:


Expands to the auxiliary (assigned to variable with &= assignment operator) value of variable (see Variables).


Expands to the primary value of variable.


The directory cross product of the tokens in variable and the tokens in the expanded value of list is returned. The first . lhs operand produces a . in the cross product. All rhs absolute path (rooted at /) operands are collected, in order, after all other products have been computed, regardless of the lhs operands.


If value is null then null is expanded and returned, otherwise non-null is expanded and returned. <del> may be any delimiter character. Y? may be abbreviated as ?.

A special form of the Y operator is $(S:Y<del><del>null<del>O) which returns the expansion of value if non-null, otherwise the expanded value of null.

To illustrate some of the above operators:

FILES = a.h b.h c.h x.c y.c z.c

$(HEADERS:/^/-I/)       →   -Ia.h -Ib.h -Ic.h
$(FILES:N=*.c:/ /:/G)   →   x.c:y.c:z.c

Automatic Variables
The following variables are automatically defined and updated by nmake:


The current option settings suitable for use on nmake command lines. The options are listed using the −o option-by-name style and only those option settings different from the default are listed.


1 if the named option is set and non-zero, otherwise null.


The current option settings suitable for use by set. Only those option settings different from the default are listed.


The current setting for the named option, suitable for use by set.


The list of command line script arguments and assignments for variables that are prerequisites of the atom .EXPORT.


The current target name.


In regular rules $(>) is the list of all explicit file prerequisites of the current target that are out of date with the target. It may be null even if the current target action has triggered. In metarules $(>) is the first %-pattern prerequisite, also called the primary metarule prerequisite and is never null.


The stem of the current metarule match, or the arguments of a function (see .FUNCTION of the Special Atoms section).


The list of all explicit file prerequisites of the current target.


The list of all explicit prerequisites of the current target.


The list of all implicit and explicit state variable prerequisites of the current target. Implicit state variable prerequisites are generated by the language dependent scan.


The list of all implicit and explicit file prerequisites of the current target. Implicit file prerequisites are generated by the language dependent scan.


The list of all prerequisites of the current target. This includes all implicit and explicit state variable and file prerequisites.


If the current target is a state variable then $(#) is the state variable value, otherwise it is the unbound atom name.


The action for the current target.


If the current target has been bound to a file in other than the top view then $(^) is set to the original (lower view) binding and $(<) is set to new (top view) binding, otherwise $(^) is null.

$(. . .)

Represents all the atoms, rules and state variables used when making .MAKEINIT.

Each repeated occurrence of the automatic variable name character in the variable expansion causes the parent of the current target to be used as a reference. For example, $(<<) is the name of the parent of the current target and $(**) is the list of all its prerequisites. $(catom) references information for atom instead of the current target. Notice that .IGNORE, .STATE, .USE and .VIRTUAL atoms are not included in $(<), $(>), $(*), or $(!) automatic variable expansions.

Assertion Operators
Assertion operators provide fine control over makefile assertions. Each operator is an atom whose action is executed whenever the atom appears as an operator in an assertion. Assertion operators are defined by assertions:

":operator:" : .OPERATOR

where the operator name syntax is :: and :identifier:. and the operator name must be quoted in its defining assertion. An operator is activated by an assertion of the form:

lhs :operator: rhs

The operator action is executed with $(<) set to lhs, $(>) set to rhs, and $(@) set to commands. No variable expansion is done on lhs, rhs, or commands.

Special Atoms
The Special Atoms defined by nmake all have the form .ID, where "ID" is any string of capital letters, dots, or numbers. Users can define their own Special Atoms, which do not have to begin with dot (.). The following atoms are special to nmake and fall into one or more of these types, depending on the context:

action rule

Action used for nmake control.

assertion attribute

Provides fine control over : dependency operator assertions.

dynamic attribute

Assigned to target atoms by listing attribute names as prerequisites in assertions. Dynamic atom attributes may be tested using the :A=attribute: edit operator.

dynamic list

Prerequisites are used to control nmake actions.

immediate rule

Invokes an nmake action when appearing as a target in assertions at assertion time . The prerequisites and actions are cleared after the assertion.

pattern association rule

The meaning of the attribute is applied to the atoms matching the specified pattern. pattern is given in one of the following formats: string match (SOURCE.%.c, .BIND.−l%), suffix match (.SOURCE.c), or attribute match (.INSERT.%.ARCHIVE).

readonly attribute

Maintained by nmake and may not be explicitly assigned.

readonly list

Prerequisites maintained by nmake.

sequence atom

Sequence atoms are made at specific times during nmake execution and are ignored if not specified. Sequence atom shell actions are always executed in the foreground. Assert intermediate rules (with actions) and append these to the sequence atom prerequisite list to avoid attribute or base and global rule clashes.

The special atoms are:

Only file prerequisites can make .ACCEPT atoms out of date.

.ACCEPT [immediaterule]

The prerequisite atoms are accepted as being up to date. However, subsequent file prerequisites may make the atoms out of date.

.ACTIONWRAP [actionrule]

If defined, the .ACTIONWRAP rule action is expanded in place of each shell action prior to command execution. The expansion takes place in the original rule context so that automatic variables refer to the original rule values. In particular, $(@) expands to the action for the original rule. For example,


echo making target $(<)

causes each triggered shell action block to expand to

echo making target <original target name>
<expanded original action>

with the result that a message including the original rule target name would be output as the first step in each triggered shell action.

.AFTER [dynamicattribute]

.AFTER prerequisites are made after the action for the target atom has completed.

.ALWAYS [dynamicattribute]

The noexec option inhibits the execution of shell actions. However, shell actions for .ALWAYS targets are executed even with noexec on.

.APPEND.pattern [patternassociationrule]

The prerequisites of .APPEND.pattern are appended to the prerequisite list of each target atom which matches pattern immediately before the target prerequisites are made. Notice that pattern must be %.ARCHIVE for .ARCHIVE targets and %.COMMAND for .COMMAND targets.

.ARCHIVE [dynamicattribute]

Target atoms with the .ARCHIVE attribute are treated as archives (see ar(1)). Binding a .ARCHIVE target atom also binds the archive members to the target. .ARCHIVE may be used as a pseudo-suffix for .APPEND and .INSERT.

.ARGS [dynamiclist]

The prerequisites of .ARGS are the command line target arguments. If, after making the .INIT sequence atom .ARGS has no prerequisites then the prerequisites of .MAIN are copied to .ARGS. As each prerequisite of .ARGS is made it is removed from the .ARGS prerequisite list.

.ATTRIBUTE [dynamicattribute]

Marks the target as a named attribute. Named attributes may be tested using the :A=attribute: edit operator. A maximum of 32 named attributes may be defined. The prerequisites of .ATTRIBUTE constitute the list of all named attributes.

.ATTRIBUTE.pattern [patternassociationrule]

When an atom which matches .pattern is bound, it inherits the attributes of .ATTRIBUTE.pattern.

.BEFORE [dynamicattribute]

.BEFORE prerequisites are made just before the action for the target atom is executed.

.BIND [immediaterule]

The prerequisite atoms are bound.

.BIND.pattern [patternassociationrule]

Specifies binding rules to be used when an atom cannot be bound using the normal rules. The return value is new binding.

.BOUND [readonlyattribute]

Marks bound atoms.

.BUILT [readonlyattribute]

Marks state rule atoms corresponding to atoms that have been built.

.CLEAR [assertionattribute]

Clears the attributes, prerequisites and action for the targets in the assertion.

.COMMAND [dynamicattribute]

Marks target atoms that bind to executable command files. .COMMAND may be used as a pseudo-suffix for .APPEND and .INSERT.

.COMPINIT [sequenceatom]

This atom is made when the input makefiles are (re)compiled, just before the make object file is written.

.DEBUG [immediaterule / actionrule]

.DEBUG is an alias for .QUERY (see .QUERY).

.DONE [sequenceatom]

This is the last atom made before nmake terminates execution.

.DONTCARE [dynamicattribute]

If a .DONTCARE target cannot be made nmake continues as if it existed, otherwise an error is issued and nmake either discontinues work on the target parent and siblings if keepgoing is on or it terminates processing and exits.

.ENTRIES [readonlyattribute]

Marks scanned directory or archive atoms that have entries (members).

.ERROR [sequenceatom]

This atom is executed when an error is encountered and the compile option is off. If the .ERROR make action block returns 0 (default), control returns to the point after the error. If the action block returns −1, then the error processing continues.

.EXISTS [readonlyattribute]

Marks atoms that have been successfully made.

.EXPORT [dynamiclist]

The prerequisites are treated as variable names to be included in $(=) automatic variable expansions.

.FAILED [readonlyattribute]

Marks atoms that have been unsuccessfully made.

.FILE [readonlyattribute]

Marks atoms bound to existing files.

.FORCE [dynamicattribute]

An atom with this attribute is always out of date the first time it is made during a single nmake execution.

.FOREGROUND [dynamicattribute]

The target action blocks until all other actions have completed. Normally nmake makes future prerequisites while concurrent actions are being executed, however, a .FOREGROUND target causes nmake to block until the corresponding action completes.

.FUNCTION [dynamicattribute]

A compound .USE attribute used in the default base rules composed from .USE .ATTRIBUTE .MAKE .FUNCTIONAL .VIRTUAL .FORCE .REPEAT dynamic attributes.

.FUNCTIONAL [dynamicattribute]

A functional atom is associated with a variable by the same name. Each time the variable is expanded the corresponding atom is made before the variable value is determined. For example,


return $(*.SOURCE:L<=*.c)

In this example, $(src) evaluates to all the .c files in the directories specified as prerequisites of .SOURCE (listed in the ascending order). Also, .FUNCTIONAL special atom provides argument support. For example,


return $(%:T=F)

one can call it by $(V a1 ... an), where a1 ... an is the list of arguments that can be referenced by $(%).

.GLOBALFILES [readonlylist]

The prerequisites are the list of global makefiles specified by the global option.

.IGNORE [dynamicattribute]

Prevents any parent targets from becoming out of date with the target, even if the target has just been built. This allows initialization sequences to be specified for individual atoms:

main : init header
     echo "executed if header is newer than main"
init : .IGNORE
     echo "always executed for main"

.IMMEDIATE [dynamicattribute]

An atom with this attribute is made immediately after each assertion of the atom.

.IMMEDIATE [immediaterule]

The prerequisites and action are made each time this atom is asserted.

.IMPLICIT [dynamicattribute]

This target attribute causes the implicit metarules to be applied even if there is no action but prerequisites have been specified for the target. Otherwise the implicit metarules are only applied to targets with no explicit actions and prerequisites. This attribute turns the .TERMINAL attribute off at assertion time.

.INIT [sequenceatom]

Made after the .MAKEINIT sequence atom.

.INSERT [assertionattribute]

Causes the prerequisites to be inserted before rather than appended to the target prerequisite list.

.INSERT.pattern [patternassociationrule]

The prerequisites of .INSERT.pattern are inserted onto the prerequisite list of each target atom which matches .pattern immediately before the target prerequisites are made. Notice that .pattern must be .ARCHIVE for .ARCHIVE targets and .COMMAND for .COMMAND targets.

.INTERNAL [readonlylist]

This atom is used internally and appears here for completeness.

.INTERRUPT [sequenceatom]

This atom is made when an interrupt signal is caught. The engine state may become corrupted by actions triggered while .INTERRUPT is active. If the interrupt occurs while .QUERY is being made and set nointerrupt is executed by .INTERRUPT then after .INTERRUPT is made nmake continues from the point where the interrupt occurred, otherwise nmake exits with non-zero status.

.JOINT [dynamicattribute]

The action causes all targets on the left hand side to be jointly built with respect to the prerequisites on the right.

.LOCAL [dynamicattribute]

An atom with this attribute is made on the local machine after each assertion of the atom when the coshell is active, no-op otherwise (see coshell(1)).

.LOCAL [immediaterule]

The prerequisites and action are made on the local machine each time this atom is asserted when the coshell is active, no-op otherwise (see coshell(1)).

.MAIN [dynamiclist]

If, after the .INIT target has been made, .ARGS has no prerequisites then the prerequisites of .MAIN are appended onto .ARGS. If not explicitly asserted in the input makefiles then the first prerequisite of .MAIN is set to be the first target in the input makefile that is neither a special atom nor a metarule.

.MAKE [dynamicattribute]

Causes the target action to be read by nmake rather than executed by the shell. Such actions are always read, even with noexec on.

.MAKE [immediaterule]

The prerequisites and action are made each time this atom is asserted.

.MAKEDONE [sequenceatom]

Made after the .DONE sequence atom.

.MAKEFILES [readonlylist]

The prerequisites are the list of makefiles specified by the file option.

.MAKEINIT [sequenceatom]

This target is made just after the statefile has been loaded. The base rules typically use this atom to initialize the nmake engine. For this reason the user should not redefine the .MAKEINIT action or attributes. However, it is safe to insert or append prerequisites onto .MAKEINIT.

.MAKING [readonlyattribute]

Marks each atom whose action is executing.

.MEMBER [readonlyattribute]

Marks an atom that is a member of a bound archive.

.METARULE [readonlylist]

The ordered list of LHS metarule patterns for all asserted metarules excluding the % match-all metarules. This list determines the metarule application order.

.MULTIPLE [dynamicattribute]

Normally each assertion removes duplicate prerequisites from the end of the target atom prerequisites list. .MULTIPLE atoms are allowed to appear more than one in a prerequisite list.

.NOCROSSPRODUCT.pattern [patternassociationrule]

When this special atom is applied as a prerequisite to .SOURCE.pattern2 the items matching .pattern in the .SOURCE.pattern2 list are not expanded for each node of the viewpath when SOURCE.pattern2 is expanded. Instead the matching items are expanded once as they are specified in the .SOURCE.pattern2 list with their paths being canonicalized. This is useful for some types of files that can be specified in search paths. For example,


.NOTYET [readonlyattribute]

Marks atoms that have not been made.

.NULL [assertionattribute]

Assigns the null action to the target atoms. Used when an action must be present, usually to force source files with prerequisites to be accepted.

.OPERATOR [dynamicattribute]

This attribute marks the target as an operator to be applied when reading makefiles. Assertion operator names must match either :: or :identifier:.

.OPTIONS [readonlylist]

The prerequisites are the options declared by the option option.

.PARAMETER [dynamicattribute]

State variables with the .PARAMETER attribute are not expanded by the :T=D: and :T=E: edit operators.

.QUERY [immediaterule]

Full atom and state information is listed for each prerequisite.

.QUERY [actionrule]

Making .QUERY places nmake in an interactive loop. Input entered at the make> prompt may be any valid makefile input. However, parsing readahead requires that a blank line follow an interactive assertion before it takes effect. If a list of atoms is entered without an assertion or assignment operator then the atoms are listed as if they were prerequisites of the .QUERY immediate rule. The interactive loop is exited by entering control-D (or quit) from the keyboard. The assertion .INTERRUPT : .QUERY causes the interactive loop to be entered on interrupts. The interactive loop can also be invoked by specifying the .QUERY Special Atom on the command line. The following command line will invoke the interactive loop:

$ nmake -f nmake_filename .QUERY

or, more commonly,

$ nmake -f nmake_filename query

.READ [dynamicattribute]

The standard output of the action is read and interpreted as nmake statements.

.REBIND [immediaterule]

Each prerequisite is unbound and bound again as if it had already been made.

.REGULAR [readonlyattribute]

Marks atoms that are bound to regular files.

.REPEAT [dynamicattribute]

By default an atom is made at most once per nmake invocation. .REPEAT marks atoms that are to be made repeatedly. .FORCE is required to force the action to be triggered each time the atom is made.

.REQUIRE.pattern [patternassociationrule]

Modifies the binding algorithm to allow a bound atom to map to a list of bound atoms. For example:


return −lcs −lnsl −lsocket

will return the entire list specified above every time −lcs is called:

−lcs → −lcs −lnsl −lsocket

.RETAIN [immediaterule]

The prerequisites are variable names whose values are to be retained in the statefile.

.SCAN [dynamicattribute]

Used for defining scanning rules for a project specific language that are not defined in the default base rules (see makerules(1) for the complete list of defined scan strategies).

.SCAN.x [dynamicattribute]

Marks an atom (when bound to a file) to be scanned for implicit prerequisites using the .x scan strategy. .ATTRIBUTE.pattern : .SCAN.x is asserted for each of the scan strategies listed in makerules(1).

.SCAN.NULL [dynamicattribute]

Inhibits scanning. Used to override .ATTRIBUTE.pattern scan strategies.

.SCAN.STATE [dynamicattribute]

Marks candidate state variables for scanning.

.SCAN.IGNORE [dynamicattribute]

No-op scan strategies.

.SCANNED [readonlyattribute]

Marks archive and directory atoms that have been scanned for members (implicit prerequisites) and records this information in the statefile. The .SCANNED attribute may be removed from the statefile with −SCANNED assertion, thus causing nmake to rescan the file being scanned at a later time. For example,

t :: t.c
t.c : -SCANNED

t.c file is being scanned by nmake using .SCAN.c scan strategy and it is marked with .SCANNED attribute. t.c : -SCANNED nullifies this action.

.SEMAPHORE [dynamicattribute]

Limits the number of executing shell actions for target atoms having the same .SEMAPHORE prerequisite. Each .SEMAPHORE within an assertion increments the semaphore count by 1. The maximum semaphore count is 7. The following example makes the shell actions for a and b mutually exclusive.

set jobs=10
all : a b
.sema : .SEMAPHORE
a b : .sema

.SOURCE [dynamiclist]

The prerequisites of .SOURCE are directories to be scanned when searching for files. The (left to right) directory order is important; the first directory containing the file is used. The directory . is always searched first.

.SOURCE.pattern [patternassociationrule]

The prerequisites of .SOURCE.pattern are directories to be scanned when searching for files which match suffix .pattern. If the file is not found then the directories specified by the prerequisites of .SOURCE are checked. The (left to right) directory order is important; the first directory containing the file is used. The directory . is always searched first. The implicit dependency scan strategy (see .SCAN) may augment or override the default .SOURCE search for individual atoms.

.SPECIAL [assertionattribute]

Target atoms in the assertion are not appended to the prerequisites of .MAIN and multiple action diagnostics are inhibited.

.STATE [dynamicattribute]

Non-.STATEVAR atoms with this attribute are treated as state variables with no implied connection to an nmake variable.

.STATE [immediaterule]

The prerequisites are variable names that are marked as candidate implicit state variable prerequisites (see Variables).

.STATERULE [readonlyattribute]

Marks internal state rule atoms that are used to store state information.

.STATEVAR [readonlyattribute]

Marks state variable atoms.

.TARGET [readonlyattribute]

Marks atoms that appeared as the target of an assertion.

.TERMINAL [dynamicattribute]

This attribute allows only .TERMINAL metarules to be applied to the target. Otherwise metarules are applied to targets with no explicit actions and prerequisites. This attribute turns the .IMPLICIT attribute off at assertion time. For metarule assertions, .TERMINAL marks unconstrained metarules that may be applied only to .TERMINAL targets or non-generated source files. .TERMINAL attribute may also be applied to directories that do not have subdirectories. If a .SOURCE directory has .TERMINAL attribute, nmake will not search that directory for subdirectories. This can be used as an optimization technique when there are many .SOURCE directories that do not have subdirectories and there are many files with the directory prefixes (saves on unnecessary filename look-ups).

.TMPLIST [readonlylist]

This atom is used internally and appears here for completeness.

.TRIGGERED [readonlyattribute]

Marks atoms whose actions have triggered during the current nmake execution.

.UNBIND [immediaterule]

Each prerequisite is unbound as if it had not been bound.

.USE [dynamicattribute]

Marks the target as a .USE atom. Any target having a .USE atom as a prerequisite will be built using the .USE atom action and attributes. The leftmost .USE prerequisite takes precedence.

.VIEW [readonlylist]

The prerequisites are view directory path names. . is by default the first view directory. A view directory is a directory from which nmake could be executed. .VIEW is initialized from the MAKEPATH and VPATH environment variables.

.VIRTUAL [dynamicattribute]

A .VIRTUAL atom never binds to a file. .VIRTUAL atom times are saved in the statefile.


Used to control synchronization when making a list of prerequisites. A in a prerequisite list causes nmake to wait until the preceding prerequisite’s actions are complete before continuing.

Command Execution
Each shell action is sent as a unit to sh via coshell(3). sh echos commands within actions as they are executed unless the silent option is on. Since actions are sent as a unit, special shell constructs (case, if, for, while) may cross newline boundaries without newline escapes.

Commands within actions returning nonzero status (see intro(1)) cause nmake to stop unless the ignore or keepgoing option is on.

nmake works only with Bourne-based shells such as sh(1) and ksh(1). nmake is optimized to work with ksh(1). COSHELL environment variable must point to either ksh, sh, or the network shell server coshell(1).

Special Commands

Causes the exit status of shell-command to be ignored.

silent shell-command

Prevents shell-command from being printed by the shell, if possible. silent must precede ignore if both are to be used. set +x prevents subsequent commands from being printed by the shell up to and including the next set −x.

The jobs option allows nmake to build many targets concurrently. The builds are synchronized using the target dependency graph. Actions for targets with the .FOREGROUND attribute block until all other jobs have completed. Prerequisites with the .SEMAPHORE attribute are used for mutual exclusion.

All actions should be written with concurrency in mind. Most problems occur when commands generate files with fixed names, such as yacc(1) and lex(1).

attributes match the regular expression .[.A−Z][.A−Z0−9]*. User attributes match the regular expression .[.A−Z][.a−z0−9]*. Intermediate targets match the regular expression .[.a−z][.a−z0−9]*. Use $COTEMP (see Environment Variables) to generate temporary file names. To avoid conflicts with the base rules the user should not define upper case atom or variable names with . as the first character.


Both short and long options may be specified anywhere on the command line. Short options are preceded by or + with + turning the option off. Long options are preceded by −− (dash dash). As with assignments, command line options override makefile option settings. The files Makeargs and makeargs (current directory only; no viewpathing) are checked in order for additional options. Only one file is read; each line is interpreted as a single argument and is inserted before the first argument of the original command line. # as the first character in a line denotes a comment, otherwise all lines (including blank lines) are significant.

All options have a string name and can be set using the −o [no]name[=value] option-by-name form or −−[no]name[=value] long form on the command line as well as set in the makefile using the set command (i.e. set [no]name[=value] ). The popular options also have a corresponding flag letter for the short option form; in some cases using the flag letter is the inverse of using the option name. The default values are off or 0 unless otherwise noted. [inverted] denotes that the flag letter has the opposite meaning of the string name (i.e. −n is noexec). The option names and corresponding flags (if any) are:


Accept any existing targets that are newer than their corresponding file prerequisites as being up to date.



must be set along with compile in order to compile base or global makefiles.



Tells nmake to believe the statefile information. When used in the form −o believe=level, it tells nmake to believe the statefile information for views greater than or equal to level. This provides an optimization for projects that can certify files in views greater than or equal to level are up-to-date. In cases where there are a large number of files on the lower level views and only a few on the top levels, this option may save significant time by eliminating the need for stat(2) system calls on the lower-level files.

−−byname=[no]name=[value] ...
[no]name=[value] ...

Set option name by name.



Disable compatibility warning messages.



Force the makefiles to be compiled into a single nmake object file. nmake exits after the files are compiled. To compile a global makefile −b −f makefile must be specified.


Provide a debug trace of nmake’s actions. The number argument level selects the debug level; higher levels produce more output. Levels 4 and higher are only enabled in debugging versions of nmake (currently all distributed versions). To avoid unnecessary noise during the engine bootstrap: if level is less than 20 then all levels are disabled during the early bootstrap and if level is 1, then debug level 1 is not turned on until after the .INIT sequence atom has been made.



Prevents nmake from automatically triggering a probe of the C/C++ compiler. When the option is in effect, nmake will not trigger a probe under any condition. This option allows users of build rules that do not involve a C/C++ compiler to conveniently bypass automatic probe and allow nmake to continue. It is also useful to administrators who want to prevent end users from kicking off a probe. If variable disable_probe_message = ERRORLEVEL message is defined then the user defined message will be printed when probe is needed but is disabled. If ERRORLEVEL is 2 or less then a warning is issued. If ERRORLEVEL is 3 or greater then an error will be issued and nmake will exit with an exit code of ERRORLEVEL − 2. Setting the CC variable to null is equal to setting disableautomaticprobe and setting disable_probe_message to null.


−E id

id is appended to the error and debug trace identification. Useful for tracing recursive nmake actions.


−n [inverted]

noexec causes shell actions to be traced and printed but not executed and also inhibits makefile and statefile compilations. Shell actions for targets with the .ALWAYS attribute, however, are executed even with noexec.



Causes the files referenced by the include statement to be textually expanded into the including-file (similar to the #include C/C++ preprocessor directive). The expanded information is placed in the file $(MAKEFILE:B).mi. If the name of the makefile is Makefile or myrules.mk then the expanded file is Makefile.mi or myrules.mi respectively.



Used with 3D File System on main machine and coshell (see coshell(1)) to access non-3D machines. The expandview option forces nmake to generate full path names for viewpathing.



Prints an explanation for actions taken. When used with the list option can be used to print explain messages from a statefile—nmake −lef filename. See also the explainlog option.


Save explain messages in the statefile with the associated triggered target(s). Allows explain messages to be retrieved from a statefile after a build is complete whether or not the explain option was used. This option is enabled by default, use −−noexplainlog to disable. To list the explain messages from a statefile see the explain option.


reads the descriptions in makefile. If makefile is , then the default makefile names are not checked. More than one file option may appear; the files are read in order from left to right. A statefile may be specified to read and dump its contents (see the list option).



Force all active targets to be out of date.


Similar to the file option, except that makefile is treated as a global makefile. This means that the default makefiles will still be checked if no file options appear.



Ignore error exit codes from shell action commands.



Override locking protocols. Normally, only one nmake is allowed to execute on a given makefile.


Passed to cpp(1) for makefile preprocessing.


See .INTERRUPT above.


Specifies that nmake may execute up to level target actions concurrently (see also NPROC environment variable). level=0 causes nmake to block for the completion of each action before proceeding. The default level=1 allows nmake to determine the next out of date target while the previous action is executing.



If the shell action for the current target returns error exit status, continue working on sibling targets that do not depend on the current target.



List variable and rule definitions after the makefiles are read and exit after the listing. The targets are neither checked nor updated. When run on a statefile using the −f option (e.g. nmake −lf statefile) the variable and rule definitions and explain messages can be dumped from the statefile. May be used in conjunction with the ruledump, vardump, and explain options.



Generates the make abstract machine language equivalent of the current makefile on standard output.



If the statefile version does not match the nmake version then run with readstate and accept on.



Like the exec option, this option will trace and print the shell actions for targets and not execute the action along with not compiling the makefile or updating the statefile. However, unlike exec, shell actions for targets with the .ALWAYS Special Atom are not executed. The difference between this option (−N) and exec (−n) is that −N overrides .ALWAYS.


Define a new option name. flag is the command-line option letter; name is the command-line option name. [type] overrides the default Boolean option type. type may be


name is a Boolean option


name is a numeric option


name is a string-valued option.


name is not to be expanded in $(−).

x type may be combined with any of the other types. The optional function is the name of a function in the makefile that acts based on the value of name.


Override explicit actions by applying matching metarule actions if possible. Also inhibits statefile updates.



Force makefiles to be preprocessed (deprecated).


Ignore the previous state by not reading any statefiles. The number argument level specifies which statefiles are read from the viewpath. The statefiles in all the viewpath levels up to and including level are read. The rest are ignored. If level is omitted, then all statefiles are ignored.


Force the input makefiles to be read rather than loading the corresponding nmake object files. This option is generated automatically when nmake object file inconsistencies are detected. Level is used as an internal recursion check (nmake automatically re-execs itself with the reread option when it determines that the makefile needs to be recompiled).



List the detailed status of each rule after all targets have been made. If list is also set then the listing occurs before any targets are made and nmake exits immediately after the listing. When used on a statefile dumps the rules from the statefile (use with the list option when dumping a statefile—nmake −lrf filename).


noscan inhibits the implicit file dependency scan algorithms controlled by the .SCAN and .SCAN.suffix attributes. scan is the default.



Execute but do not print shell actions.


This option is on by default when viewpathing is used. nostrictview enables non-strict viewpathing. The difference between strictview and nostrictview is in the order in which the .SOURCE[.pattern] directories are searched. For example:

If viewpath is "v0:v1" and .SOURCE : A B, the strictview interpretation is:

v0 v1 v0/A v1/A v0/B v1/B

The non-strictview interpretation is:

v0 v0/A v0/B v1 v1/A v1/B


Expands shell actions in the target directory when the target name contains a directory prefix.


Enable the internal debug tests specified by the bit vector bits. Some tests enable verbose tracing while others change the internal algorithms. Don’t use this option unless you know what the tests do.


Time that differ by less than seconds seconds are considered equal. This option may be necessary for certain network file system implementations that fail to maintain clock integrity between systems on the network.



Touch the modify date of targets, bypassing the actions that build them. Only existing targets are touched.



List variable assignments. Useful in conjunction with the debug option. If list is also set then the listing occurs before any targets are made and nmake exits immediately after the listing. When used on a statefile dumps the variables from the statefile (use with the list option when dumping a statefile—nmake −lvf filename).


Print version information and exit.



Enable more detailed source file warning messages.


nowritestate prevents the statefile from being updated on exit.


The file names and directories used by the nmake engine are parameterized using variables.

Engine Variables
These variables are assigned default values by the nmake engine itself. Some of the values are determined at installation time while others are determined by each invocation environment.


The COTEMP environment variable is generated and set to a different value for each shell command. It is 10 characters long and can be used for temporary file names, so names of the form


will be upto 14 characters to satisfy the system V file name length restriction.


The path name of the current nmake program suitable for use as a shell command or in an execvp(3) system call.


A colon separated list of the candidate argument file names.


The name of the first makefile.


A colon separated list of candidate implicit makefile names.


Current nmake integer recursion level.


The directory for nmake related files, e.g., base rules.


The name of the (deprecated) makefile preprocessor.


The name of the default base rules. The base rules file must be a compiled make object file and is named by changing the suffix in $(MAKERULES) to .mo and binding the result using the directories in .SOURCE.mk. makerules may be an absolute path name.


Used to initialize .SOURCE.mk. All makefiles, including compiled make object files and files included by makefiles, are bound using the directories in .SOURCE.mk.


The nmake engine version stamp.


Executed via execvp(3) when the first input makefile is not a valid nmake makefile.


A colon separated list of directories to be used for probe(1) information. Used in conjunction with the localprobe base rule variable. See makerules(1) for further information.


The absolute pathname of the current directory.


Set to the path that goes from the viewpath node root to the current working directory.


Set to the relative path that gets from the current working directory to the viewpath node root.

Uninitialized Variables
These variables have null default values and are used only when defined.

The name of the shell used to execute shell actions. execvp(3) is used to execute the shell. If COSHELL is not defined, then ksh, sh, and /bin/sh are tried in order.


A space separated pair of the build tool script (other than nmake) and the conversion tool. Used for compile time makefile conversion. For example:

export MAKECONVERT=’Make.src "nmakegen $(>)"’


A colon separated list of environment variable names, the values of which override any makefile variable assignments.


A colon separated list of directory names from which nmake could be run on the current makefile. These directories are used by the initialization script to initialize the .VIEW special atom. . is always the first view by default.


The maximum number of coshell processes that are to be executed simultaneously (the environment variable equivalent of −j).


May be 0/NO/no to suppress changing the umask to match the current directory permissions, or 1/YES/yes/null to change the umask. For compatibility the umask change is enabled by default. Any other UMASKCHANGE value generates a warning and keeps the umask change enabled.


A colon separated list of viewpath node names. The node names are converted to MAKEPATH directories that are used by the initialization script to initialize the .VIEW special atom. VPATH is ignored if nmake is not executing within the first viewpath node.


Makefile, makefile

default makefiles, tried in order

Makeargs, makeargs

default argument files, tried in order


engine initialization script


default compiled base rules


make lock file


make object file


make statefile


nmake diagnostic messages are preceded by make:. If a diagnostic is produced while reading a makefile (or executing a .MAKE action) then the makefile (or atom) name and line number are included. Debug trace messages are preceded by debug-level: where level is the message trace level. panic diagnostics include the nmake version, source file and source line number where the error was detected. There is no graceful recovery from a panic (i.e., your statefile usually gets trashed); mail the panic message with a brief description of the context to your nmake provider.


nmake User's Guide
nmake Reference Manual
nmake Web Site
S. I. Feldman, Make − A Program for Maintaining Computer Programs
E. G. Bradford, An Augmented Version of Make
V. B. Erickson, J. F. Pellegrin, Build − A Software Construction Tool
G. S. Fowler, The Fourth Generation Make
3d(1), ar(1), cc(1), coshell(1), cpp(1), lex(1), libcoshell(3),
make(1), makerules(1), probe(1), sh(1), xargs(1), yacc(1)


Any variables that are expanded while reading makefiles are frozen into the corresponding nmake object file. If the value of a frozen variable changes from one invocation of nmake to the next, either in a command line definition or in the environment, then a warning is issued and the makefile is automatically recompiled. Most frozen variable expansions can be deferred by entering $(var) as $$(var).

Some commands return nonzero status inappropriately. Use ignore command to overcome any difficulties.

nmake only detects source files that it builds or those that exist before nmake is executed.

nmake 14 June 2012 NMAKE(1)