MASH-MAKE(1) MASH-MAKE(1)
NAME
mash-make - builtin `make' functionality
SYNOPSIS
load make
make [ -clear ]
depends [ target ]
match pattern
rules [ pattern ]
DESCRIPTION
Make is a loadable builtin for mash. It can be taught about
dependencies that exist between components of a program and
rules for reconstructing the components of a program.
Make will examine file modification times to determine which
components need to be updated and will issue commands to
reconstruct them in the correct sequence. It will update a
target if any of its prerequisites are more up to date than
the target or if the target does not exist.
Typically, dependencies and rules are kept in a file called
mashfile. The sequence
load make
run mashfile
is used to load the make builtin and read the rules from
mashfile. Thereafter, the command
make target
will perform the correct sequence of operations to recon-
struct target and its dependents.
A dependency is specified in mash with a line of the form:
target-list : dependent-list ;
or
target-list : dependent-list { rules } ;
Each of the targets in target-list depends upon each of the
dependents in dependent-list. The optional rules specify how
to build the targets. For example
lflags = -Cg;
rotta.dis : rotta.b rotta.m { limbo $lflags rotta.b };
If the rules are omitted make must be able to infer them
Page 1 Plan 9 (printed 11/22/24)
MASH-MAKE(1) MASH-MAKE(1)
from implicit rules.
An implicit rule is defined with a line of the form:
pattern :~ dependency { rules }
If pattern matches a target that make needs to build then
make will build the target by first making the dependency
and then applying the rules. The wildcard components of the
matched target are available in the dependency and the rules
as variables $1, $2, $3... with $1 containing the text
matched by the first wildcard, $2 the second wildcard and so
on. The whole of the target is available in the variable $0.
For example,
/*/*.m :~ $2.m { cp $2.m /$1/$2.m };
/module/rotta.m: rotta.m;
/altmodule/frame.m: frame.m;
More commonly, implicit rules are defined to provide make
with knowledge of how to compile limbo source to produce Dis
format binaries. Typically,
*.dis :~ $1.b { limbo $lflags $1.b};
/dis/*.dis :~ $1.dis { cp $1.dis /dis};
A target is built with the command
make target
The list of rules can be reset with
make -clear
The list of dependencies for a target or for all targets can
be displayed with the command
depends [ target ]
The rules that match a pattern and the components of the
pattern can be displayed with
match 'pattern'
Taking care to hide the pattern from mash file name pattern
matching with quotes. The command
rules [ pattern ]
will display all the rules or the rules that apply to pat-
tern pattern (if given).
Page 2 Plan 9 (printed 11/22/24)
MASH-MAKE(1) MASH-MAKE(1)
SOURCE
/appl/cmd/mash/make.b
SEE ALSO
mash(1)
Page 3 Plan 9 (printed 11/22/24)