..

..

At least one makefile must be specified. If no file options are present then \*(nM 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 .EX 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 \*(nM 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. .L # preceded by zero or more space characters ( space or tab ) starting in column 1 is interpreted by cpp , otherwise text between .L # (preceded by at least one space character) and newline is treated as a comment by \*(nM . 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 \*(nM object file. The next time \*(nM 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 \*(nM 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 \*(nM object files. Refer to the compile option below for more information.

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

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.

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 .LR :, .LR #, .L = and .L + must be enclosed in double quotes. For example: .EX target : ":file1" file2 action

A "state variable" is an atom associated with an \*(nM 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 \*(nM object file algorithms. The state variable atom for the \*(nM variable variable is ( variable ) . For example: .EX x.o : (DEBUG) specifies that .L x.o depends on the definition of the variable .LR DEBUG . The contents of the statefile can be listed by executing .EX \*(nM -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.

bind the atom An atom retains its binding until \*(nM 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 \*(nM 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 \*(nM execution.

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 fules, $(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

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.

error " level message" message is output as an \*(nM error message with severity level level . level may be one of:

eval

0

...

end

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

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

for variable patterns ...

0

...

end

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"

0

...

elif " expression"

...

else

...

end

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 :

set [no]name=[value] Sets options using option-by-name format (see OPTIONS ).

while " expression"

0

...

end

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

print " message" Prints message to the standard output. (This is the same as \f3error \f20 message.)

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.

The following makefile specifies that .L program depends on two files .L a.o and .LR b.o , and that they in turn depend on .c files and a common file .LR header.h . .EX 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 .LR "%.s2 : %.s1" . Any prerequisites following .L %.s1 are transferred to each target when the metarule is applied. For example, a metarule for making optimized .o files from .c files is .EX %.o : %.c (CC) (CCFLAGS) $(CC) $(CCFLAGS) -c -o $(<) $(>)

Notice that the .o targets also depend on the values of the .L CC and .L CCFLAGS \*(nM variables. If the current target is .L a.o then \*(nM infers the following from the .L "%.o : %.c" metarule: .EX a.o : a.c (CC) (CCFLAGS) cc -O -c -o a.o a.c In this case the stem is \f5a, \f5$(CC) and \f5$(CCFLAGS) expand to \f5cc and \f5-O, respectively.

Assuming the .L "%.o : %.c" metarule has been asserted, the example can be stated more briefly: .EX 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 .L "%.z : %.m" and .L "%.m : %.a" and the source file x.a , the target file x.z will be generated by first applying .L "%.m : %.a" to x.a to build x.m , and then applying .L "%.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 .EX % : .TERMINAL RCS/%,v $(CO) $(COFLAGS) $(>) is a metarule that generates source files from RCS version files in the RCS subdirectory.

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 \e 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:

A[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.

0 B[=base]

D[=directory]

S[=suffix]

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 \*(nM 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).

C <del>old<del>new<del> [G] 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 / .

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

F =format Converts tokens according to format . format may be a concatenation of the following:

G =pattern 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).

I =list 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.

K=pfx 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.

M[\|!\|]=pattern Selects tokens [ \|not\| ] matching the egrep (1) style regular expression pattern .

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

O[\|!\|]|[<relop><n>] 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.

P[\|!\|]=op Treats the tokens as file path names and applies the path name operator op . op may be:

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

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

0 T =type

T =type ? return

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:

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

X =list 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.

Y <del>non-null<del>null<del> 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 ? .

To illustrate some of the above operators: .EX FILES = a.h b.h c.h x.c y.c z.c HEADERS = $(FILES:N=*.h) $(HEADERS:/^/-I/) \(-> -Ia.h -Ib.h -Ic.h $(FILES:N=*.c:/ /:/G) \(-> x.c:y.c:z.c

$(-) The current option settings suitable for use on \*(nM command lines. The options are listed using the -o option-by-name style and only those option settings different from the default are listed.

$(- option ) 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.

$(\+ option ) 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.

$(>) The list of all explicit file prerequisites of the current target that are out of date with the target. $(>) is always non- null for triggered metarule actions but otherwise may be null (even if the current target action has triggered).

$(%) The stem of the current metarule match, or the arguments of a function (see \.FUNCTION in Special Atoms).

$(*) 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. $(c atom ) 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.

.ACCEPT "\|\|\s-1[dynamic\|attribute]\s+1" Only file prerequisites can make .ACCEPT atoms out of date.

.ACCEPT "\|\|\s-1[immediate\|rule]\s+1" The prerequisite atoms are accepted as being up to date. However, subsequent file prerequisites may make the atoms out of date.

.AFTER "\|\|\s-1[dynamic\|attribute]\s+1" .AFTER prerequisites are made after the action for the target atom has completed.

.ALWAYS "\|\|\s-1[dynamic\|attribute]\s+1" The noexec option inhibits the execution of shell actions. However, shell actions for .ALWAYS targets are executed even with noexec on.

.APPEND ".pattern\|\|\s-1[pattern\|association\|rule]\s+1" 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 "\|\|\s-1[dynamic\|attribute]\s+1" 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 "\|\|\s-1[dynamic\|list]\s+1" 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 "\|\|\s-1[dynamic\|attribute]\s+1" 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\|\|\s-1[pattern\|association\|rule]\s+1" When an atom which matches .pattern is bound, it inherits the attributes of .ATTRIBUTE.pattern.

.BEFORE "\|\|\s-1[dynamic\|attribute]\s+1" .BEFORE prerequisites are made just before the action for the target atom is executed.

.BIND "\|\|\s-1[immediate\|rule]\s+1" The prerequisite atoms are bound.

.BIND ".pattern\|\|\s-1[pattern\|association\|rule]\s+1" Specifies binding rules to be used when an atom cannot be bound using the normal rules. The return value is new binding.

.BOUND "\|\|\s-1[readonly\|attribute]\s+1" Marks bound atoms.

.BUILT "\|\|\s-1[readonly\|attribute]\s+1" Marks state rule atoms corresponding to atoms that have been built.

.CLEAR "\|\|\s-1[assertion\|attribute]\s+1" Clears the attributes, prerequisites and action for the targets in the assertion.

.COMMAND "\|\|\s-1[dynamic\|attribute]\s+1" Marks target atoms that bind to executable command files. .COMMAND may be used as a pseudo-suffix for .APPEND and .INSERT .

.COMPINIT "\|\|\s-1[sequence\|atom]\s+1" This atom is made when the input makefiles are (re)compiled, just before the make object file is written.

.DEBUG "\|\|\s-1[immediate\|rule / action\|rule]\s+1" .DEBUG is an alias for .QUERY (see .QUERY ).

.DONE "\|\|\s-1[sequence\|atom]\s+1" This is the last atom made before \*(nM terminates execution.

.DONTCARE "\|\|\s-1[dynamic\|attribute]\s+1" If a .DONTCARE target cannot be made \*(nM continues as if it existed, otherwise an error is issued and \*(nM either discontinues work on the target parent and siblings if keepgoing is on or it terminates processing and exits.

.ENTRIES "\|\|\s-1[readonly\|attribute]\s+1" Marks scanned directory or archive atoms that have entries (members).

.ERROR "\|\|\s-1[sequence\|atom]\s+1" 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 "\|\|\s-1[readonly\|attribute]\s+1" Marks atoms that have been successfully made.

.EXPORT "\|\|\s-1[dynamic\|list]\s+1" The prerequisites are treated as variable names to be included in $(=) automatic variable expansions.

.FAILED "\|\|\s-1[readonly\|attribute]\s+1" Marks atoms that have been unsuccessfully made.

.FILE "\|\|\s-1[readonly\|attribute]\s+1" Marks atoms bound to existing files.

.FORCE "\|\|\s-1[dynamic\|attribute]\s+1" An atom with this attribute is always out of date the first time it is made during a single \*(nM execution.

.FOREGROUND "\|\|\s-1[dynamic\|attribute]\s+1" The target action blocks until all other actions have completed. Normally \*(nM makes future prerequisites while concurrent actions are being executed, however, a .FOREGROUND target causes \*(nM to block until the corresponding action completes.

.FUNCTION "\|\|\s-1[dynamic\|attribute]\s+1" A compound .USE attribute used in the default base rules composed from .USE .ATTRIBUTE .MAKE .FUNCTIONAL .VIRTUAL .FORCE .REPEAT dynamic attributes.

.FUNCTIONAL "\|\|\s-1[dynamic\|attribute]\s+1" 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, .EX src : .MAKE .FUNCTIONAL return $(*.SOURCE:L<=*.c) In this example, \f5$(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, .EX V : .MAKE .FUNCTIONAL return $(%:T=F) one can call it by $(V a1 ... an), where a1 ... an is the list of arguments that can be referenced by \f5$(%).

.GLOBALFILES "\|\|\s-1[readonly\|list]\s+1" The prerequisites are the list of global makefiles specified by the global option.

.IGNORE "\|\|\s-1[dynamic\|attribute]\s+1" 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: .EX main : init header echo "executed if header is newer than main" init : .IGNORE echo "always executed for main"

.IMMEDIATE "\|\|\s-1[dynamic\|attribute]\s+1" An atom with this attribute is made immediately after each assertion of the atom.

.IMMEDIATE "\|\|\s-1[immediate\|rule]\s+1" The prerequisites and action are made each time this atom is asserted.

.IMPLICIT "\|\|\s-1[dynamic\|attribute]\s+1" 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 "\|\|\s-1[sequence\|atom]\s+1" Made after the .MAKEINIT sequence atom.

.INSERT "\|\|\s-1[assertion\|attribute]\s+1" Causes the prerequisites to be inserted before rather than appended to the target prerequisite list.

.INSERT ".pattern\|\|\s-1[pattern\|association\|rule]\s+1" 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 "\|\|\s-1[readonly\|list]\s+1" This atom is used internally and appears here for completeness.

.INTERRUPT "\|\|\s-1[sequence\|atom]\s+1" 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 \*(nM continues from the point where the interrupt occurred, otherwise \*(nM exits with non-zero status.

.JOINT "\|\|\s-1[dynamic\|attribute]\s+1" The action causes all targets on the left hand side to be jointly built with respect to the prerequisites on the right.

.LOCAL "\|\|\s-1[dynamic\|attribute]\s+1" 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 "\|\|\s-1[immediate\|rule]\s+1" 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 "\|\|\s-1[dynamic\|list]\s+1" 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 "\|\|\s-1[dynamic\|attribute]\s+1" Causes the target action to be read by \*(nM rather than executed by the shell. Such actions are always read, even with noexec on.

.MAKE "\|\|\s-1[immediate\|rule]\s+1" The prerequisites and action are made each time this atom is asserted.

.MAKEDONE "\|\|\s-1[sequence\|atom]\s+1" Made after the .DONE sequence atom.

.MAKEFILES "\|\|\s-1[readonly\|list]\s+1" The prerequisites are the list of makefiles specified by the file option.

.MAKEINIT "\|\|\s-1[sequence\|atom]\s+1" This target is made just after the statefile has been loaded. The base rules typically use this atom to initialize the \*(nM 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 "\|\|\s-1[readonly\|attribute]\s+1" Marks each atom whose action is executing.

.MEMBER "\|\|\s-1[readonly\|attribute]\s+1" Marks an atom that is a member of a bound archive.

.METARULE "\|\|\s-1[readonly\|list]\s+1" The ordered list of LHS metarule patterns for all asserted metarules excluding the % match-all metarules. This list determines the metarule application order.

.MULTIPLE "\|\|\s-1[dynamic\|attribute]\s+1" 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.

.NOTYET "\|\|\s-1[readonly\|attribute]\s+1" Marks atoms that have not been made.

.NULL "\|\|\s-1[assertion\|attribute]\s+1" 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 "\|\|\s-1[dynamic\|attribute]\s+1" This attribute marks the target as an operator to be applied when reading makefiles. Assertion operator names must match either :: or : identifier : .

.PARAMETER "\|\|\s-1[dynamic\|attribute]\s+1" Marks the target as a
.I parameter
file.
A
.I parameter
file only contains definitions (i.e.,
.B #define
definitions), comments and
.B #include
statements to other files.
The modify time of a
.I parameter
file is ignored when determining the update status of corresponding targets.
State variables with the .PARAMETER attribute are not expanded by the :T=D: and :T=E: edit operators.

.QUERY "\|\|\s-1[immediate\|rule]\s+1" Full atom and state information is listed for each prerequisite.

.QUERY "\|\|\s-1[action\|rule]\s+1" Making .QUERY places \*(nM 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: \f5$ nmake -f nmake_filename .QUERY or, more commonly, \f5$ nmake -f nmake_filename query

.READ "\|\|\s-1[dynamic\|attribute]\s+1" The standard output of the action is read and interpreted as nmake statements.

.REBIND "\|\|\s-1[immediate\|rule]\s+1" Each prerequisite is unbound and bound again as if it had already been made.

.REGULAR "\|\|\s-1[readonly\|attribute]\s+1" Marks atoms that are bound to regular files.

.REPEAT "\|\|\s-1[dynamic\|attribute]\s+1" By default an atom is made at most once per \*(nM 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\|\|\s-1[pattern\|association\|rule]\s+1" Modifies the binding algorithm to allow a bound atom to map to a list of bound atoms. For example: .EX .REQUIRE.-lcs : .FUNCTION return -lcs -lnsl -lsocket will return the entire list specified above every time \f5-lcs is called: .EX -lcs \(-> -lcs -lnsl -lsocket

.RETAIN "\|\|\s-1[immediate\|rule]\s+1" The prerequisites are variable names whose values are to be retained in the statefile.

.SCAN "\|\|\s-1[dynamic\|attribute]\s+1" 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\|\|\s-1[dynamic\|attribute]\s+1" 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 "\|\|\s-1[dynamic\|attribute]\s+1" Inhibits scanning. Used to override .ATTRIBUTE .pattern scan strategies.

.SCAN.STATE "\|\|\s-1[dynamic\|attribute]\s+1" Marks candidate state variables for scanning.

.SCAN.IGNORE "\|\|\s-1[dynamic\|attribute]\s+1" No-op scan strategies.

.SCANNED "\|\|\s-1[readonly\|attribute]\s+1" 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, .EX t :: t.c t.c : -SCANNED \f5t.c file is being scanned by nmake using .SCAN.c scan strategy and it is marked with .SCANNED attribute. \f5t.c : -SCANNED nullifies this action.

.SEMAPHORE "\|\|\s-1[dynamic\|attribute]\s+1" 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. .EX set jobs=10 all : a b .sema : .SEMAPHORE a b : .sema action

.SOURCE "\|\|\s-1[dynamic\|list]\s+1" 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\|\|\s-1[pattern\|association\|rule]\s+1" 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 "\|\|\s-1[assertion\|attribute]\s+1" Target atoms in the assertion are not appended to the prerequisites of .MAIN and multiple action diagnostics are inhibited.

.STATE "\|\|\s-1[dynamic\|attribute]\s+1" Non- .STATEVAR atoms with this attribute are treated as state variables with no implied connection to an \*(nM variable.

.STATE "\|\|\s-1[immediate\|rule]\s+1" The prerequisites are variable names that are marked as candidate implicit state variable prerequisites (see Variables ).

.STATERULE "\|\|\s-1[readonly\|attribute]\s+1" Marks internal state rule atoms that are used to store state information.

.STATEVAR "\|\|\s-1[readonly\|attribute]\s+1" Marks state variable atoms.

.TARGET "\|\|\s-1[readonly\|attribute]\s+1" Marks atoms that appeared as the target of an assertion.

.TERMINAL "\|\|\s-1[dynamic\|attribute]\s+1" 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 "\|\|\s-1[readonly\|list]\s+1" This atom is used internally and appears here for completeness.

.TRIGGERED "\|\|\s-1[readonly\|attribute]\s+1" Marks atoms whose actions have triggered during the current \*(nM execution.

.UNBIND "\|\|\s-1[immediate\|rule]\s+1" Each prerequisite is unbound as if it had not been bound.

.USE "\|\|\s-1[dynamic\|attribute]\s+1" 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 "\|\|\s-1[readonly\|list]\s+1" The prerequisites are view directory path names. . is by default the first view directory. A view directory is a directory from which \*(nM could be executed. .VIEW is initialized from the MAKEPATH and VPATH environment variables.

.VIRTUAL "\|\|\s-1[dynamic\|attribute]\s+1" A .VIRTUAL atom never binds to a file. .VIRTUAL atom times are saved in the statefile.

"-" "\|\|\s-1[dynamic\|list]\s+1" Used to control synchronization when making a list of prerequisites. A - in a prerequisite list causes \*(nM to wait until the preceding prerequisite's actions are complete before continuing.

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

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

ignore " shell-command" 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" .

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).

COTEMP 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 .EX <pfx>$COTEMP<sfx> will be upto 14 characters to satisfy the system V file name length restriction.

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

MAKEARGS= Makeargs : makeargs A colon separated list of the candidate argument file names.

MAKEFILE The name of the first makefile.

MAKEFILES= Makefile : makefile A colon separated list of candidate implicit makefile names.

MAKELIB The directory for \*(nM related files, e.g., base rules.

MAKEPP= $(MAKELIB)/../cpp The name of the (deprecated) makefile preprocessor.

MAKERULES= makerules 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.

MAKERULESPATH= $(LOCALRULESPATH):$(MAKELIB):/usr/local/lib/make:/usr/lib/make 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 .

MAKEVERSION The \*(nM engine version stamp.

OLDMAKE Executed via execvp (3) when the first input makefile is not a valid \*(nM makefile.

PWD The absolute pathname of the current directory.

COSHELL 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.

MAKECONVERT A space separated pair of the build tool script (other than nmake) and the conversion tool. Used for compile time makefile conversion. For example: .EX export MAKECONVERT='Make.src "nmakegen $(>)"'

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

MAKEPATH A colon separated list of directory names from which \*(nM 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.

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

VOFFSET VOFFSET is set to the path that goes from the viewpath node root to the current working directory.

VPATH 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 \*(nM is not executing within the first viewpath node.

VROOT VROOT is set to the relative path that gets from the current working directory to the viewpath node root.