(make.info.gz) Static Usage

Info Catalog

(make.info.gz) Static Pattern

(make.info.gz) Static Pattern

(make.info.gz) Static versus Implicit

 
 4.12.1 Syntax of Static Pattern Rules
 -------------------------------------
 
 Here is the syntax of a static pattern rule:
 
      TARGETS ...: TARGET-PATTERN: PREREQ-PATTERNS ...
              COMMANDS
              ...
 
 The TARGETS list specifies the targets that the rule applies to.  The
 targets can contain wildcard characters, just like the targets of
 ordinary rules ( Using Wildcard Characters in File Names
 Wildcards.).
 
    The TARGET-PATTERN and PREREQ-PATTERNS say how to compute the
 prerequisites of each target.  Each target is matched against the
 TARGET-PATTERN to extract a part of the target name, called the "stem".
 This stem is substituted into each of the PREREQ-PATTERNS to make the
 prerequisite names (one from each PREREQ-PATTERN).
 
    Each pattern normally contains the character `%' just once.  When the
 TARGET-PATTERN matches a target, the `%' can match any part of the
 target name; this part is called the "stem".  The rest of the pattern
 must match exactly.  For example, the target `foo.o' matches the
 pattern `%.o', with `foo' as the stem.  The targets `foo.c' and
 `foo.out' do not match that pattern.
 
    The prerequisite names for each target are made by substituting the
 stem for the `%' in each prerequisite pattern.  For example, if one
 prerequisite pattern is `%.c', then substitution of the stem `foo'
 gives the prerequisite name `foo.c'.  It is legitimate to write a
 prerequisite pattern that does not contain `%'; then this prerequisite
 is the same for all targets.
 
    `%' characters in pattern rules can be quoted with preceding
 backslashes (`\').  Backslashes that would otherwise quote `%'
 characters can be quoted with more backslashes.  Backslashes that quote
 `%' characters or other backslashes are removed from the pattern before
 it is compared to file names or has a stem substituted into it.
 Backslashes that are not in danger of quoting `%' characters go
 unmolested.  For example, the pattern `the\%weird\\%pattern\\' has
 `the%weird\' preceding the operative `%' character, and `pattern\\'
 following it.  The final two backslashes are left alone because they
 cannot affect any `%' character.
 
    Here is an example, which compiles each of `foo.o' and `bar.o' from
 the corresponding `.c' file:
 
      objects = foo.o bar.o
 
      all: $(objects)
 
      $(objects): %.o: %.c
              $(CC) -c $(CFLAGS) $< -o $@
 
 Here `$<' is the automatic variable that holds the name of the
 prerequisite and `$@' is the automatic variable that holds the name of
 the target; see  Automatic Variables.
 
    Each target specified must match the target pattern; a warning is
 issued for each target that does not.  If you have a list of files,
 only some of which will match the pattern, you can use the `filter'
 function to remove nonmatching file names ( Functions for String
 Substitution and Analysis Text Functions.):
 
      files = foo.elc bar.o lose.o
 
      $(filter %.o,$(files)): %.o: %.c
              $(CC) -c $(CFLAGS) $< -o $@
      $(filter %.elc,$(files)): %.elc: %.el
              emacs -f batch-byte-compile $<
 
 In this example the result of `$(filter %.o,$(files))' is `bar.o
 lose.o', and the first static pattern rule causes each of these object
 files to be updated by compiling the corresponding C source file.  The
 result of `$(filter %.elc,$(files))' is `foo.elc', so that file is made
 from `foo.el'.
 
    Another example shows how to use `$*' in static pattern rules: 
 
      bigoutput littleoutput : %output : text.g
              generate text.g -$* > $@
 
 When the `generate' command is run, `$*' will expand to the stem,
 either `big' or `little'.
 

Info Catalog

(make.info.gz) Static Pattern

(make.info.gz) Static Pattern

(make.info.gz) Static versus Implicit