Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/misc/volume27/dmake/part16

Text File | 1992-01-29 | 40.0 KB | 1,144 lines

Newsgroups: comp.sources.misc
From: [e-mail] (Dennis Vadura)
Subject:  v27i117:  dmake - dmake Version 3.8, Part16/41
Message-ID: <[e-mail]>
X-Md4-Signature: e3f80b504f43bb68bdf03c7d50bed860
Date: Tue, 28 Jan 1992 21:40:23 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (Dennis Vadura)
Posting-number: Volume 27, Issue 117
Archive-name: dmake/part16
Environment: Atari-ST, Coherent, Mac, MSDOS, OS/2, UNIX
Supersedes: dmake: Volume 19, Issue 22-58

---- Cut Here and feed the following to sh ----
# this is dmake.shar.16 (part 16 of a multipart archive)
# do not concatenate these parts, unpack them in order with /bin/sh
# file dmake/man/dmake.nc continued
#
if test ! -r _shar_seq_.tmp; then
    echo 'Please unpack part 1 first!'
    exit 1
fi
(read Scheck
 if test "$Scheck" != 16; then
    echo Please unpack part "$Scheck" next!
    exit 1
 else
    exit 0
 fi
) < _shar_seq_.tmp || exit 1
if test -f _shar_wnt_.tmp; then
sed 's/^X//' << 'SHAR_EOF' >> 'dmake/man/dmake.nc' &&
X
X     Which takes the value of VPATH and sets .SOURCE to the same
X     set of directories as specified in VPATH.
X
PERCENT(%) RULES AND MAKING INFERENCES
X     When dmake makes a target, the target's set of prerequisites
X     (if any) must exist and the target must have a recipe which
X     dmake can use to make it.  If the makefile does not specify
X     an explicit recipe for the target then dmake uses special
X     rules to try to infer a recipe which it can use to make the
X     target.  Previous versions of Make perform this task by
X     using rules that are defined by targets of the form
X     .<suffix>.<suffix> and by using the .SUFFIXES list of suf-
X     fixes.  The exact workings of this mechanism were sometimes
X     difficult to understand and often limiting in their useful-
X     ness.  Instead, dmake supports the concept of %-meta rules.
X     The syntax and semantics of these rules differ from standard
X     rule lines as follows:
X
X          <%-target> [<attributes>] <ruleop> [<%-prerequisites>] [;<recipe>]
X
X     where %-target is a target containing exactly a single `%'
X
X
X
Version 3.70                    UW                             34
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     sign, attributes is a list (possibly empty) of attributes,
X     ruleop is the standard set of rule operators, %-prere-
X     quisites , if present, is a list of prerequisites containing
X     zero or more `%' signs, and recipe, if present, is the first
X     line of the recipe.
X
X     The %-target defines a pattern against which a target whose
X     recipe is being inferred gets matched.  The pattern match
X     goes as follows:  all chars are matched exactly from left to
X     right up to but not including the % sign in the pattern, %
X     then matches the longest string from the actual target name
X     not ending in the suffix given after the % sign in the pat-
X     tern.  Consider the following examples:
X
X          %.c       matches fred.c but not joe.c.Z
X          dir/%.c   matches dir/fred.c but not dd/fred.c
X          fred/%    matches fred/joe.c but not f/joe.c
X          %         matches anything
X
X     In each case the part of the target name that matched the %
X     sign is retained and is substituted for any % signs in the
X     prerequisite list of the %-meta rule when the rule is
X     selected during inference and dmake constructs the new
X     dependency.  As an example the following %-meta rules
X     describe the following:
X
X          %.c : %.y ; recipe...
X
X     describes how to make any file ending in .c if a correspond-
X     ing file ending in .y can be found.
X
X          foo%.o : fee%.k ; recipe...
X
X     is used to describe how to make fooxxxx.o from feexxxx.k.
X
X          %.a :; recipe...
X
X     describes how to make a file whose suffix is .a without
X     inferring any prerequisites.
X
X          %.c : %.y yaccsrc/%.y ; recipe...
X
X     is a short form for the construct:
X
X          %.c : %.y ; recipe...
X          %.c : yaccsrc/%.y ; recipe...
X
X     ie. It is possible to specify the same recipe for two
X     %-rules by giving more than one prerequisite in the prere-
X     quisite list.  A more interesting example is:
X
X          % : RCS/%,v ; co $<
X
X
X
Version 3.70                    UW                             35
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     which describes how to take any target and check it out of
X     the RCS directory if the corresponding file exists in the
X     RCS directory.  The equivalent SCCS rule would be:
X
X          % : s.% ; get $<
X
X
X     The previous RCS example defines an infinite rule, because
X     it says how to make anything from RCS/%,v, and anything also
X     includes RCS/fred.c,v.  To limit the size of the graph that
X     results from such rules dmake uses the macro variable PREP
X     (stands for % repetition).  By default the value of this
X     variable is 0, which says that no repetitions of a %-rule
X     are to be generated.  If it is set to something greater than
X     0, then that many repetitions of any infinite %-rule are
X     allowed.  If in the above example PREP was set to 1, then
X     dmake would generate the dependency graph:
X
X          % --> RCS/%,v --> RCS/RCS/%,v,v
X
X     Where each link is assigned the same recipe as the first
X     link.  PREP should be used only in special cases, since it
X     may result in a large increase in the number of possible
X     prerequisites tested.  dmake further assumes that any target
X     that has no suffix can be made from a prerequisite that has
X     at least one suffix.
X
X     dmake supports dynamic prerequisite generation for prere-
X     quisites of %-meta rules.  This is best illustrated by an
X     example.  The RCS rule shown above can infer how to check
X     out a file from a corresponding RCS file only if the target
X     is a simple file name with no directory information.  That
X     is, the above rule can infer how to find RCS/fred.c,v from
X     the target fred.c, but cannot infer how to find
X     srcdir/RCS/fred.c,v from srcdir/fred.c because the above
X     rule will cause dmake to look for RCS/srcdir/fred.c,v; which
X     does not exist (assume that srcdir has its own RCS directory
X     as is the common case).
X
X     A more versatile formulation of the above RCS check out rule
X     is the following:
X
X          % :  $$(@:d)RCS/$$(@:f),v : co $@
X
X     This rule uses the dynamic macro $@ to specify the prere-
X     quisite to try to infer.  During inference of this rule the
X     macro $@ is set to the value of the target of the %-meta
X     rule and the appropriate prerequisite is generated by
X     extracting the directory portion of the target name (if
X     any), appending the string RCS/ to it, and appending the
X     target file name with a trailing ,v attached to the previous
X     result.
X
X
X
Version 3.70                    UW                             36
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     dmake can also infer indirect prerequisites.  An inferred
X     target can have a list of prerequisites added that will not
X     show up in the value of $< but will show up in the value of
X     $? and $&.  Indirect prerequisites are specified in an
X     inference rule by quoting the prerequisite with single
X     quotes.  For example, if you had the explicit dependency:
X
X          fred.o : fred.c ; rule to make fred.o
X          fred.o : local.h
X
X     then this can be inferred for fred.o from the following
X     inference rule:
X
X          %.o : %.c 'local.h' ; rule to make a .o from a .c
X
X     You may infer indirect prerequisites that are a function of
X     the value of '%' in the current rule.  The meta-rule:
X
X          %.o : %.c '$(INC)/%.h' ; rule to make a .o from a .c
X
X     infers an indirect prerequisite found in the INC directory
X     whose name is the same as the expansion of $(INC), and the
X     prerequisite name depends on the base name of the current
X     target.  The set of indirect prerequisites is attached to
X     the meta rule in which they are specified and are inferred
X     only if the rule is used to infer a recipe for a target.
X     They do not play an active role in driving the inference
X     algorithm.  The construct:
X
X          %.o : %.c %.f 'local.h'; recipe
X
X     is equivalent to:
X
X          %.o : %.c 'local.h' : recipe
X          %.o : %.f 'local.h' : recipe
X
X
X     If any of the attributes .SETDIR, .EPILOG, .PROLOG, .SILENT,
X     .USESHELL, .SWAP, .PRECIOUS, .LIBRARY, .NOSTATE and .IGNORE
X     are given for a %-rule then when that rule is bound to a
X     target as the result of an inference, the target's set of
X     attributes is augmented by the attributes from the above set
X     that are specified in the bound %-rule.  Other attributes
X     specified for %-meta rules are not inherited by the target.
X     The .SETDIR attribute is treated in a special way.  If the
X     target already had a .SETDIR attribute set then dmake
X     changes to that directory prior to performing the inference.
X     During inference any .SETDIR attributes for the inferred
X     prerequisite are honored.  The directories must exist for a
X     %-meta rule to be selected as a possible inference path.  If
X     the directories do not exist no error message is issued,
X     instead the corresponding path in the inference graph is
X
X
X
Version 3.70                    UW                             37
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     rejected.
X
X     dmake also supports the old format special target
X     .<suffix>.<suffix> by identifying any rules of this form and
X     mapping them to the appropriate %-rule.  So for example if
X     an old makefile contains the construct:
X
X          .c.o :; cc -c $< -o $@
X
X     dmake maps this into the following %-rule:
X
X          %.o : %.c; cc -c $< -o $@
X
X     Furthermore, dmake understands several SYSV AUGMAKE special
X     targets and maps them into corresponding %-meta rules.
X     These transformation must be enabled by providing the -A
X     flag on the command line or by setting the value of AUGMAKE
X     to non-NULL.  The construct
X
X          .suff :; recipe
X
X     gets mapped into:
X
X          % : %.suff; recipe
X
X     and the construct
X
X          .c~.o :; recipe
X
X     gets mapped into:
X
X          %.o : s.%.c ; recipe
X
X     In general, a special target of the form .<str>~ is replaced
X     by the %-rule construct s.%.<str>, thereby providing support
X     for the syntax used by SYSV AUGMAKE for providing SCCS sup-
X     port.  When enabled, these mappings allow processing of
X     existing SYSV makefiles without modifications.
X
X     dmake bases all of its inferences on the inference graph
X     constructed from the %-rules defined in the makefile.  It
X     knows exactly which targets can be made from which prere-
X     quisites by making queries on the inference graph.  For this
X     reason .SUFFIXES is not needed and is completely ignored.
X
X     For a %-meta rule to be inferred as the rule whose recipe
X     will be used to make a target, the target's name must match
X     the %-target pattern, and any inferred %-prerequisite must
X     already exist or have an explicit recipe so that the prere-
X     quisite can be made.  Without transitive closure on the
X     inference graph the above rule describes precisely when an
X     inference match terminates the search.  If transitive
X
X
X
Version 3.70                    UW                             38
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     closure is enabled (the usual case), and a prerequisite does
X     not exist or cannot be made, then dmake invokes the infer-
X     ence algorithm recursively on the prerequisite to see if
X     there is some way the prerequisite can be manufactured.
X     For, if the prerequisite can be made then the current target
X     can also be made using the current %-meta rule.  This means
X     that there is no longer a need to give a rule for making a
X     .o from a .y if you have already given a rule for making a
X     .o from a .c and a .c from a .y.  In such cases dmake can
X     infer how to make the .o from the .y via the intermediary .c
X     and will remove the .c when the .o is made.  Transitive clo-
X     sure can be disabled by giving the -T switch on the command
X     line.
X
X     A word of caution.  dmake bases its transitive closure on
X     the %-meta rule targets.  When it performs transitive clo-
X     sure it infers how to make a target from a prerequisite by
X     performing a pattern match as if the potential prerequisite
X     were a new target.  The set of rules:
X
X          %.o : %.c :; rule for making .o from .c
X          %.c : %.y :; rule for making .c from .y
X          % : RCS/%,v :; check out of RCS file
X
X     will, by performing transitive closure, allow dmake to infer
X     how to make a .o from a .y using a .c as an intermediate
X     temporary file.  Additionally it will be able to infer how
X     to make a .y from an RCS file, as long as that RCS file is
X     in the RCS directory and has a name which ends in .y,v.  The
X     transitivity computation is performed dynamically for each
X     target that does not have a recipe.  This has potential to
X     be costly if the %-meta rules are not carefully specified.
X     The .NOINFER attribute is used to mark a %-meta node as
X     being a final target during inference.  Any node with this
X     attribute set will not be used for subsequent inferences.
X     As an example the node RCS/%,v is marked as a final node
X     since we know that if the RCS file does not exist there
X     likely is no other way to make it.  Thus the standard
X     startup makefile contains an entry similar to:
X          .NOINFER : RCS/%,v
X     Thereby indicating that the RCS file is the end of the
X     inference chain.
X
X     Whenever the inference algorithm determines that a target
X     can be made from more than one prerequisite and the infer-
X     ence chains for the two methods are the same length the
X     algorithm reports an ambiguity and prints the ambiguous
X     inference chains.
X
X     dmake tries to remove intermediate files resulting from
X     transitive closure if the file is not marked as being PRE-
X     CIOUS, or the -u flag was not given on the command line, and
X
X
X
Version 3.70                    UW                             39
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     if the inferred intermediate did not previously exist.
X     Intermediate targets that existed prior to being made are
X     never removed.  This is in keeping with the philosophy that
X     dmake should never remove things from the file system that
X     it did not add.  If the special target .REMOVE is defined
X     and has a recipe then dmake constructs a list of the inter-
X     mediate files to be removed and makes them prerequisites of
X     .REMOVE.  It then makes .REMOVE thereby removing the prere-
X     quisites if the recipe of .REMOVE says to.  Typically
X     .REMOVE is defined in the startup file as:
X
X          .REMOVE :; $(RM) $<
X
MAKING TARGETS
X     In order to update a target dmake must execute a recipe.
X     When a recipe needs to be executed it is first expanded so
X     that any macros in the recipe text are expanded, and it is
X     then either executed directly or passed to a shell.  dmake
X     supports two types of recipes.  The regular recipes and
X     group recipes.
X
X     When a regular recipe is invoked dmake executes each line of
X     the recipe separately using a new copy of a shell if a shell
X     is required.  Thus effects of commands do not generally per-
X     sist across recipe lines.  (e.g. cd requests in a recipe
X     line do not carry over to the next recipe line) The decision
X     on whether a shell is required to execute a command is based
X     on the value of the macro SHELLMETAS or on the specification
X     of '+' or .USESHELL for the current recipe or target respec-
X     tively.  If any character in the value of SHELLMETAS is
X     found in the expanded recipe text-line or the use of a shell
X     is requested explicitly via '+' or .USESHELL then the com-
X     mand is executed using a shell, otherwise the command is
X     executed directly.  The shell that is used for execution is
X     given by the value of the macro SHELL.  The flags that are
X     passed to the shell are given by the value of SHELLFLAGS.
X     Thus dmake constructs the command line:
X
X          $(SHELL) $(SHELLFLAGS) $(expanded_recipe_command)
X
X     Normally dmake writes the command line that it is about to
X     invoke to standard output.  If the .SILENT attribute is set
X     for the target or for the recipe line (via @), then the
X     recipe line is not echoed.
X
X     Group recipe processing is similar to that of regular
X     recipes, except that a shell is always invoked.  The shell
X     that is invoked is given by the value of the macro GROUP-
X     SHELL, and its flags are taken from the value of the macro
X     GROUPFLAGS.  If a target has the .PROLOG attribute set then
X     dmake prepends to the shell script the recipe associated
X     with the special target .GROUPPROLOG, and if the attribute
X
X
X
Version 3.70                    UW                             40
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     .EPILOG is set as well, then the recipe associated with the
X     special target .GROUPEPILOG is appended to the script file.
X     This facility can be used to always prepend a common header
X     and common trailer to group recipes.  Group recipes are
X     echoed to standard output just like standard recipes, but
X     are enclosed by lines beginning with [ and ].
X
X     The recipe flags [+,-,%,@] are recognized at the start of a
X     recipe line even if they appear in a macro.  For example:
X
X          SH = +
X          all:
X               $(SH)echo hi
X
X     is completely equivalent to writing
X
X          SH = +
X          all:
X               +echo hi
X
X
X     The last step performed by dmake prior to running a recipe
X     is to set the macro CMNDNAME to the name of the command to
X     execute (determined by finding the first white-space ending
X     token in the command line).  It then sets the macro CMNDARGS
X     to be the remainder of the line.  dmake then expands the
X     macro COMMAND which by default is set to
X
X          COMMAND = $(CMNDNAME) $(CMNDARGS)
X
X     The result of this final expansion is the command that will
X     be executed.  The reason for this expansion is to allow for
X     a different interface to the argument passing facilities
X     (esp. under DOS) than that provided by dmake. You can for
X     example define COMMAND to be
X
X          COMMAND = $(CMNDNAME) @$(mktmp $(CMNDARGS))
X
X     which dumps the arguments into a temporary file and runs the
X     command
X
X          $(CMNDNAME) @/tmp/ASAD23043
X
X     which has a much shorter argument list.  It is now up to the
X     command to use the supplied argument as the source for all
X     other arguments.  As an optimization, if COMMAND is not
X     defined dmake does not perform the above expansion.  On sys-
X     tems, such as UNIX, that handle long command lines this pro-
X     vides a slight saving in processing the makefiles.
X
X
X
X
X
X
Version 3.70                    UW                             41
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
MAKING LIBRARIES
X     Libraries are easy to maintain using dmake.  A library is a
X     file containing a collection of object files.  Thus to make
X     a library you simply specify it as a target with the
X     .LIBRARY attribute set and specify its list of prere-
X     quisites.  The prerequisites should be the object members
X     that are to go into the library.  When dmake makes the
X     library target it uses the .LIBRARY attribute to pass to the
X     prerequisites the .LIBMEMBER attribute and the name of the
X     library.  This enables the file binding mechanism to look
X     for the member in the library if an appropriate object file
X     cannot be found. A small example best illustrates this.
X
X          mylib.a .LIBRARY : mem1.o mem2.o mem3.o
X               rules for making library...
X               # remember to remove .o's when lib is made
X
X          # equivalent to:  '%.o : %.c ; ...'
X          .c.o :; rules for making .o from .c say
X
X     dmake will use the .c.o rule for making the library members
X     if appropriate .c files can be found using the search rules.
X     NOTE:  this is not specific in any way to C programs, they
X     are simply used as an example.
X
X     dmake tries to handle the old library construct format in a
X     sensible way.  The construct lib(member.o) is separated and
X     the lib portion is declared as a library target.  The new
X     target is defined with the .LIBRARY attribute set and the
X     member.o portion of the construct is declared as a prere-
X     quisite of the lib target.  If the construct lib(member.o)
X     appears as a prerequisite of a target in the makefile, that
X     target has the new name of the lib assigned as its prere-
X     quisite.  Thus the following example:
X
X          a.out : ml.a(a.o) ml.a(b.o); $(CC) -o $@  $<
X
X          .c.o :; $(CC) -c $(CFLAGS) -o $@  $<
X          %.a:
X               ar rv $@ $?
X               ranlib $@
X               rm -rf $?
X
X     constructs the following dependency graph.
X
X          a.out : ml.a; $(CC) -o $@  $<
X          ml.a .LIBRARY : a.o b.o
X
X          %.o : %.c ; $(CC) -c $(CFLAGS) -o $@  $<
X          %.a :
X               ar rv $@ $?
X               ranlib $@
X
X
X
Version 3.70                    UW                             42
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X               rm -rf $?
X
X     and making a.out then works as expected.
X
X     The same thing happens for any target of the form
X     lib((entry)).  These targets have an additional feature in
X     that the entry target has the .SYMBOL attribute set automat-
X     ically.
X
X     NOTE:  If the notion of entry points is supported by the
X     archive and by dmake (currently not the case) then dmake
X     will search the archive for the entry point and return not
X     only the modification time of the member which defines the
X     entry but also the name of the member file.  This name will
X     then replace entry and will be used for making the member
X     file.  Once bound to an archive member the .SYMBOL attribute
X     is removed from the target.  This feature is presently dis-
X     abled as there is little standardization among archive for-
X     mats, and we have yet to find a makefile utilizing this
X     feature (possibly due to the fact that it is unimplemented
X     in most versions of UNIX Make).
X
X     Finally, when dmake looks for a library member it must first
X     locate the library file.  It does so by first looking for
X     the library relative to the current directory and if it is
X     not found it then looks relative to the current value of
X     $(TMD).  This allows commonly used libraries to be kept near
X     the root of a source tree and to be easily found by dmake.
X
KEEP STATE
X     dmake supports the keeping of state information for targets
X     that it makes whenever the macro .KEEP_STATE is assigned a
X     value.  The value of the macro should be the name of a state
X     file that will contain the state information.  If state
X     keeping is enabled then each target that does not poses the
X     .NOSTATE attribute will have a record written into the state
X     file indicating the target's name, the current directory,
X     the command used to update the target, and which, if any, ::
X     rule is being used.  When you make this target again if any
X     of this information does not match the previous settings and
X     the target is not out dated it will still be re-made.  The
X     assumption is that one of the conditions above has changed
X     and that we wish to remake the target.  For example, state
X     keeping is used in the maintenance of dmake to test compile
X     different versions of the source using different compilers.
X     Changing the compiler causes the compilation flags to be
X     modified and hence all sources to be recompiled.
X
X     The state file is an ascii file and is portable, however it
X     is not in human readable form as the entries represent hash
X     keys of the above information.
X
X
X
X
Version 3.70                    UW                             43
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     The Sun Microsystem's Make construct
X
X          .KEEP_STATE :
X
X     is recognized and is mapped to .KEEP_STATE:=_state.mk.  The
X     dmake version of state keeping does not include scanning C
X     source files for dependencies like Sun Make.  This is
X     specific to C programs and it was felt that it does not
X     belong in make.  dmake instead provides the tool, cdepend,
X     to scan C source files and to produce depedency information.
X     Users are free to modify cdepend to produce other dependency
X     files.  (NOTE: cdepend does not come with the distribution
X     at this time, but will be available in a patch in the near
X     future)
X
MULTI PROCESSING
X     If the architecture supports it then dmake is capable of
X     making a target's prerequisites in parallel.  dmake will
X     make as much in parallel as it can and use a number of child
X     processes up to the maximum specified by MAXPROCESS or by
X     the value supplied to the -P command line flag.  A parallel
X     make is enabled by setting the value of MAXPROCESS (either
X     directly or via -P option) to a value which is > 1.  dmake
X     guarantees that all dependencies as specified in the
X     makefile are honored.  A target will not be made until all
X     of its prerequisites have been made.  If a parallel make is
X     being performed then the following restrictions on parallel-
X     ism are enforced.
X
X          1.   Individual recipe lines in a non-group recipe are
X               performed sequentially in the order in which they
X               are specified within the makefile and in parallel
X               with the recipes of other targets.
X
X          2.   If a target contains multiple recipe definitions
X               (cf. :: rules) then these are performed sequen-
X               tially in the order in which the :: rules are
X               specified within the makefile and in parallel with
X               the recipes of other targets.
X
X          3.   If a target rule contains the `!' modifier, then
X               the recipe is performed sequentially for the list
X               of outdated prerequisites and in parallel with the
X               recipes of other targets.
X
X          4.   If a target has the .SEQUENTIAL attribute set then
X               all of its prerequisites are made sequentially
X               relative to one another (as if MAXPROCESS=1), but
X               in parallel with other targets in the makefile.
X
X     Note:  If you specify a parallel make then the order of tar-
X     get update and the order in which the associated recipes are
X
X
X
Version 3.70                    UW                             44
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     invoked will not correspond to that displayed by the -n
X     flag.
X
CONDITIONALS
X     dmake supports a makefile construct called a conditional.
X     It allows the user to conditionally select portions of
X     makefile text for input processing and to discard other por-
X     tions.  This becomes useful for writing makefiles that are
X     intended to function for more than one target host and
X     environment.  The conditional expression is specified as
X     follows:
X
X          .IF  expression
X             ... if text ...
X          .ELIF  expression
X             ... if text ...
X          .ELSE
X             ... else text ...
X          .END
X
X     The .ELSE and .ELIF portions are optional, and the condi-
X     tionals may be nested (ie.  the text may contain another
X     conditional).  .IF, .ELSE, and .END may appear anywhere in
X     the makefile, but a single conditional expression may not
X     span multiple makefiles.
X
X     expression can be one of the following three forms:
X
X          <text> | <text> == <text> | <text> != <text>
X
X     where text is either text or a macro expression.  In any
X     case, before the comparison is made, the expression is
X     expanded.  The text portions are then selected and compared.
X     White space at the start and end of the text portion is dis-
X     carded before the comparison.  This means that a macro that
X     evaluates to nothing but white space is considered a NULL
X     value for the purpose of the comparison.  In the first case
X     the expression evaluates TRUE if the text is not NULL other-
X     wise it evaluates FALSE.  The remaining two cases both
X     evaluate the expression on the basis of a string comparison.
X     If a macro expression needs to be equated to a NULL string
X     then compare it to the value of the macro $(NULL).  You can
X     use the $(shell ...) macro to construct more complex test
X     expressions.
X
EXAMPLES
X          # A simple example showing how to use make
X          #
X          prgm : a.o b.o
X               cc a.o b.o -o prgm
X          a.o : a.c g.h
X               cc a.c -o $@
X
X
X
Version 3.70                    UW                             45
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X          b.o : b.c g.h
X               cc b.c -o $@
X
X     In the previous example prgm is remade only if a.o and/or
X     b.o is out of date with respect to prgm.  These dependencies
X     can be stated more concisely by using the inference rules
X     defined in the standard startup file.  The default rule for
X     making .o's from .c's looks something like this:
X
X          %.o : %.c; cc -c $(CFLAGS) -o $@ $<
X
X     Since there exists a rule (defined in the startup file) for
X     making .o's from .c's dmake will use that rule for manufac-
X     turing a .o from a .c and we can specify our dependencies
X     more concisely.
X
X          prgm : a.o b.o
X               cc -o prgm $<
X          a.o b.o : g.h
X
X     A more general way to say the above using the new macro
X     expansions would be:
X
X          SRC = a b
X          OBJ = {$(SRC)}.o
X
X          prgm : $(OBJ)
X               cc -o $@ $<
X
X          $(OBJ) : g.h
X
X     If we want to keep the objects in a separate directory,
X     called objdir, then we would write something like this.
X
X          SRC = a b
X          OBJ = {$(SRC)}.o
X
X          prgm : $(OBJ)
X               cc $< -o $@
X
X          $(OBJ) : g.h
X          %.o : %.c
X               $(CC) -c $(CFLAGS) -o $(@:f) $<
X               mv $(@:f) objdir
X
X          .SOURCE.o : objdir       # tell make to look here for .o's
X
X     An example of building library members would go something
X     like this: (NOTE:  The same rules as above will be used to
X     produce .o's from .c's)
X
X          SRC  = a b
X
X
X
Version 3.70                    UW                             46
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X          LIB  = lib
X          LIBm = { $(SRC) }.o
X
X          prgm: $(LIB)
X               cc -o $@ $(LIB)
X
X          $(LIB) .LIBRARY : $(LIBm)
X               ar rv $@ $<
X               rm $<
X
X     Finally, suppose that each of the source files in the previ-
X     ous example had the `:' character in their target name.
X     Then we would write the above example as:
X
X          SRC  = f:a f:b
X          LIB  = lib
X          LIBm = "{ $(SRC) }.o"         # put quotes around each token
X
X          prgm: $(LIB)
X               cc -o $@ $(LIB)
X
X          $(LIB) .LIBRARY : $(LIBm)
X               ar rv $@ $<
X               rm $<
X
COMPATIBILITY
X     There are two notable differences between dmake and the
X     standard version of BSD UNIX 4.2/4.3 Make.
X
X          1. BSD UNIX 4.2/4.3 Make supports wild card filename
X             expansion for prerequisite names.  Thus if a direc-
X             tory contains a.h, b.h and c.h, then a line like
X
X                  target: *.h
X
X             will cause UNIX make to expand the *.h into "a.h b.h
X             c.h".  dmake does not support this type of filename
X             expansion.
X
X          2. Unlike UNIX make, touching a library member causes
X             dmake to search the library for the member name and
X             to update the library time stamp.  This is only
X             implemented in the UNIX version.  MSDOS and other
X             versions may not have librarians that keep file time
X             stamps, as a result dmake touches the library file
X             itself, and prints a warning.
X
X     dmake is not compatible with GNU Make.  In particular it
X     does not understand GNU Make's macro expansions that query
X     the file system.
X
X
X
X
X
Version 3.70                    UW                             47
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     dmake is fully compatible with SYSV AUGMAKE, and supports
X     the following AUGMAKE features:
X
X          1. The word include appearing at the start of a line
X             can be used instead of the ".INCLUDE :" construct
X             understood by dmake.
X
X          2. The macro modifier expression $(macro:str=sub) is
X             understood and is equivalent to the expression
X             $(macro:s/str/sub), with the restriction that str
X             must match the following regular expression:
X
X                  str[ |\t][ |\t]*
X
X             (ie. str only matches at the end of a token where
X             str is a suffix and is terminated by a space, a tab,
X             or end of line) Normally sub is expanded before the
X             substitution is made, if you specify -A on the com-
X             mand line then sub is not expanded.
X
X          3. The macro % is defined to be $@ (ie. $% expands to
X             the same value as $@).
X
X          4. The AUGMAKE notion of libraries is handled
X             correctly.
X
X          5. When defining special targets for the inference
X             rules and the AUGMAKE special target handling is
X             enabled then the special target .X is equivalent to
X             the %-rule "% : %.X".
X
X          6. Directories are always made if you specify -A.  This
X             is consistent with other UNIX versions of Make.
X
X          7. Makefiles that utilize virtual targets to force mak-
X             ing of other targets work as expected if AUGMAKE
X             special target handling is enabled.  For example:
X
X                  FRC:
X                  myprog.o : myprog.c $(FRC) ; ...
X
X             Works as expected if you issue the command
X
X                  'dmake -A FRC=FRC'
X
X             but fails with a 'don't know how to make FRC' error
X             message if you do not specify AUGMAKE special target
X             handling via the -A flag (or by setting AUGMAKE:=yes
X             internally).
X
X
X
X
X
X
Version 3.70                    UW                             48
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
LIMITS
X     In some environments the length of an argument string is
X     restricted.  (e.g. MSDOS command line arguments cannot be
X     longer than 128 bytes if you are using the standard
X     command.com command interpreter as your shell, dmake text
X     diversions may help in these situations.)
X
PORTABILITY
X     To write makefiles that can be moved from one environment to
X     another requires some forethought.  In particular you must
X     define as macros all those things that may be different in
X     the new environment.  dmake has two facilities that help to
X     support writing portable makefiles, recursive macros and
X     conditional expressions.  The recursive macros, allow one to
X     define environment configurations that allow different
X     environments for similar types of operating systems.  For
X     example the same make script can be used for SYSV and BSD
X     but with different macro definitions.
X
X     To write a makefile that is portable between UNIX and MSDOS
X     requires both features since in almost all cases you will
X     need to define new recipes for making targets.  The recipes
X     will probably be quite different since the capabilities of
X     the tools on each machine are different.  Different macros
X     will be needed to help handle the smaller differences in the
X     two environments.
X
FILES
X     Makefile, makefile, startup.mk (use dmake -V to tell you
X     where the startup file is)
X
SEE ALSO
X     sh(1), csh(1), touch(1), f77(1), pc(1), cc(1)
X     S.I. Feldman  Make - A Program for Maintaining Computer Pro-
X     grams
X
AUTHOR
X     Dennis Vadura, CS Dept. University of Waterloo.
X     [e-mail]
X     Many thanks to Carl Seger for his helpful suggestions, and
X     to Trevor John Thompson for his many excellent ideas and
X     informative bug reports.
X
BUGS
X     Some system commands return non-zero status inappropriately.
X     Use -i (`-' within the makefile) to overcome the difficulty.
X
X     Some systems do not have easily accessible time stamps for
X     library members (MSDOS, AMIGA, etc) for these dmake uses the
X     time stamp of the library instead and prints a warning the
X     first time it does so.  This is almost always ok, except
X     when multiple makefiles update a single library file.  In
X
X
X
Version 3.70                    UW                             49
X
X
X
X
DMAKE(p)             Unsupported Free Software            DMAKE(p)
X
X
X
X     these instances it is possible to miss an update if one is
X     not careful.
X
X     This man page is way too long.
X
WARNINGS
X     Rules supported by make(1) may not work if transitive clo-
X     sure is turned off (-T, .NOINFER).
X
X     PWD from csh/ksh will cause problems if a cd operation is
X     performed and -e or -E option is used.
X
X     Using internal macros such as COMMAND, may wreak havoc if
X     you don't understand their functionality.
X
X     If multiple MACRO=line arguments appear on the command line,
X     only the first is used.  Beware of this in conjunction with
X     the MAKEMACROS variable.
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
Version 3.70                    UW                             50
SHAR_EOF
chmod 0640 dmake/man/dmake.nc ||
echo 'restore of dmake/man/dmake.nc failed'
Wc_c="`wc -c < 'dmake/man/dmake.nc'`"
test 119471 -eq "$Wc_c" ||
    echo 'dmake/man/dmake.nc: original size 119471, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/man/dmake.tf ==============
if test -f 'dmake/man/dmake.tf' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/man/dmake.tf (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/man/dmake.tf' &&
.\" Copyright (c) 1990 Dennis Vadura, All rights reserved.
.\"
.ds TB "0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.2i +0.5i +0.5i +2.0i
.de Ip
.fi
.nr Ip \w'\\$1 'u
.IP "\\$1" \\n(Ipu
\\$2
.nf
..
.de Is
.nr )I \w'\\$1'u
..
.de Ii
.in \\n()Ru
.nr )E 1
.ns
.ne 1.1v
.it 1 }N
.di ]B
\&\\$1
..
.TH DMAKE p  "UW" "Version 3.70" "Unsupported Free Software"
.SH NAME
\fBdmake\fR \- maintain program groups, or interdependent files
.SH SYNOPSIS
.B dmake
[\-ABceEhiknpqrsStTuVx] [\-v{dfimt}] [\-P#] [\-{f|C|K} file]
[macro[*][+][:]=\fIvalue\fP ...] [target ...]
.SH DESCRIPTION
.PP
.B dmake
executes commands found in an external file called a
.I makefile
to update one or more target names.
Each target may depend on zero or more prerequisite targets.
If any of the target's prerequisites is newer than the target or if the target
itself does not exist, then
SHAR_EOF
true || echo 'restore of dmake/man/dmake.tf failed'
fi
echo 'End of part 16, continue with part 17'
echo 17 > _shar_seq_.tmp
exit 0
exit 0 # Just in case...