Lines Matching refs:rule
127 * Rule Introduction:: What a rule looks like.
163 * Multiple Targets:: When to make use of several targets in a rule.
168 * Double-Colon:: How to use a special kind of rule to allow
291 * Using Implicit:: How to use an existing implicit rule
299 * Suffix Rules:: The old-fashioned style of implicit rule.
318 * Archive Update:: The implicit rule for archive member targets.
320 * Archive Suffix Rules:: You can write a special kind of suffix rule
488 * Rule Introduction:: What a rule looks like.
500 @cindex rule, introduction to
501 @cindex makefile rule parts
502 @cindex parts of makefile rule
528 A rule may have more than one command, each on its own line.
532 Usually a command is in a rule with prerequisites and serves to create a
533 target file if any of the prerequisites change. However, the rule that
535 example, the rule containing the delete command associated with the
538 A @dfn{rule}, then, explains how and when to remake certain files
539 which are the targets of the particular rule. @code{make} carries out
541 rule can also explain how and when to carry out an action.
632 file properly. All @code{make} does is execute the commands in the rule
639 do not want to carry out the actions in this rule, @samp{clean} is not a prerequisite of any other …
641 it specifically. Note that this rule not only is not a prerequisite, it
642 also does not have any prerequisites, so the only purpose of the rule
669 update the executable program @file{edit}; therefore, we put that rule
680 processing the first rule. In the example, this rule is for relinking
681 @file{edit}; but before @code{make} can fully process this rule, it
684 processed according to its own rule. These rules say to update each
691 prerequisites of the goal. If some other rule is not depended on by the
692 goal (or anything it depends on, etc.), that rule is not processed,
721 In our example, we had to list all the object files twice in the rule for
797 @cindex implicit rule, introduction to
798 @cindex rule, implicit, introduction to
802 @dfn{implicit rule} for updating a @samp{.o} file from a correspondingly
890 could write a @code{make} rule for cleaning our example editor:
899 In practice, we might want to write the rule in a somewhat more
917 A rule such as this should not be placed at the beginning of the
919 example makefile, we want the rule for @code{edit}, which recompiles
922 Since @code{clean} is not a prerequisite of @code{edit}, this rule will not
924 order to make the rule run, we have to type @samp{make clean}.
957 @cindex rule, explicit, definition of
958 @cindex explicit rule, definition of
960 An @dfn{explicit rule} says when and how to remake one or more files,
961 called the rule's @dfn{targets}. It lists the other files that the
966 @cindex rule, implicit, definition of
967 @cindex implicit rule, definition of
969 An @dfn{implicit rule} says when and how to remake a class of files
1343 @c would match an implicit rule and become an ``implicit target''. The
1402 rule which says how to update it (found either in that very makefile or
1403 in another one) or if an implicit rule applies to it (@pxref{Implicit
1412 want to keep @code{make} from performing an implicit rule search on
1414 preventing implicit rule lookup to do so. For example, you can write an
1415 explicit rule with the makefile as the target, and an empty command
1418 If the makefiles specify a double-colon rule to remake a file with
1421 double-colon rule with commands but no prerequisites will be remade every
1426 remake makefiles which are specified as targets of a double-colon rule
1481 @cindex match-anything rule, used to override
1483 you can use a match-anything pattern rule to say that to remake any
1505 commands from the pattern rule: @samp{make -f Makefile bar}. If
1506 @file{Makefile} provides a rule for updating @file{bar}, @code{make}
1507 will apply the rule. And likewise for any other target that
1510 The way this works is that the pattern rule has a pattern of just
1511 @samp{%}, so it matches any target whatever. The rule specifies a
1514 commands to prevent @code{make} from searching for an implicit rule to
1515 build it---otherwise it would apply the same match-anything rule to
1581 not set until the command script for that rule is invoked. If you
1589 @cindex implicit rule, expansion
1590 @cindex pattern rule, expansion
1591 @cindex explicit rule, expansion
1593 A rule is always expanded the same way, regardless of the form:
1602 general rule is true for explicit rules, pattern rules, suffix rules,
1715 the different types of rule definitions that @code{make} understands.
1727 rule for this target. @code{$$^} and @code{$$+} evaluate to the list
1750 the rule with the command script is always evaluated last.
1769 As @code{make} searches for an implicit rule, it substitutes the stem
1770 and then performs secondary expansion for every rule with a matching
1784 When the implicit rule is tried for target @file{foo}, @code{$$<}
1810 @cindex rule, how to write
1814 A @dfn{rule} appears in the makefile and says when and how to remake
1815 certain files, called the rule's @dfn{targets} (most often only one per rule).
1824 rule in the first makefile. If the first rule has multiple targets,
1828 defines a pattern rule has no effect on the default goal.
1831 Therefore, we usually write the makefile so that the first rule is the
1849 * Multiple Targets:: When to make use of several targets in a rule.
1854 * Double-Colon:: How to use a special kind of rule to allow
1864 Here is an example of a rule:
1875 This rule says two things:
1894 @cindex rule syntax
1896 In general, a rule looks like this:
1914 @cindex rule targets
1921 target per rule, but occasionally there is a reason to have more
1947 A rule tells @code{make} two things: when the targets are out of date,
1951 @cindex rule prerequisites
2056 Wildcards can be used in the commands of a rule, where they are expanded
2057 by the shell. For example, here is a rule to delete all the object files:
2067 Wildcards are also useful in the prerequisites of a rule. With the
2068 following rule in the makefile, @samp{make print} will print all the
2081 This rule uses @file{print} as an empty target file; see @ref{Empty
2128 expansion happens in the rule for @file{foo}, so that each @emph{existing}
2217 (This takes advantage of the implicit rule for compiling C programs, so
2283 With this value of @code{VPATH}, the following rule,
2473 this cannot change the commands of the rule; they will execute as written.
2480 list of all the prerequisites of the rule, including the names of
2510 @cindex implicit rule, and directory search
2511 @cindex implicit rule, and @code{VPATH}
2512 @cindex rule, implicit, and directory search
2513 @cindex rule, implicit, and @code{VPATH}
2519 For example, when a file @file{foo.o} has no explicit rule, @code{make}
2520 considers implicit rules, such as the built-in rule to compile
2524 directories, the implicit rule for C compilation is applied.
2602 If you write a rule whose commands will not create the target file, the
2636 remade from other files, @code{make} skips the implicit rule search for
2642 phony target, then you write the rule, like this:
2656 subdirectories to be built. One way to handle this is with one rule
2671 detected in a submake is not noted by this rule, so it will continue to
2677 (@pxref{Parallel, ,Parallel Execution}), since there is only one rule.
2759 @cindex rule, no commands or prerequisites
2761 If a rule has no prerequisites or commands, and the target of the rule
2763 been updated whenever its rule is run. This implies that all targets
2800 last-modification time, when the rule's commands were last executed. It
2820 With this rule, @samp{make print} will execute the @code{lpr} command if
2856 file mentioned as a prerequisite, but not as a target in a rule, will have
2874 You can also list the target pattern of an implicit rule (such as
2917 makefile, then @code{make} will delete the target of a rule if it has
3005 Any defined implicit rule suffix also counts as a special target if it
3017 @cindex several targets in a rule
3019 @cindex rule, with multiple targets
3021 A rule with multiple targets is equivalent to writing many rules, each with
3024 actual target name into the command using @samp{$@@}. The rule contributes
3075 You cannot do this with multiple targets in an ordinary rule, but you can
3076 do it with a @dfn{static pattern rule}.
3083 @cindex rule, multiple for one target
3088 the target. If the target is older than any prerequisite from any rule,
3092 more than one rule gives commands for the same file, @code{make} uses
3101 An extra rule with just prerequisites can be used to give a few extra
3136 searches for an applicable implicit rule to find some commands
3141 @cindex static pattern rule
3142 @cindex rule, static pattern
3160 @cindex static pattern rule, syntax of
3163 Here is the syntax of a static pattern rule:
3172 The @var{targets} list specifies the targets that the rule applies to.
3251 @file{bar.o lose.o}, and the first static pattern rule causes each of
3272 @cindex rule, static pattern versus implicit
3273 @cindex static pattern rule, versus implicit
3275 A static pattern rule has much in common with an implicit rule defined as a
3276 pattern rule (@pxref{Pattern Rules, ,Defining and Redefining Pattern Rules}).
3279 @emph{when} the rule applies.
3281 An implicit rule @emph{can} apply to any target that matches its pattern,
3284 implicit rule appears applicable, only one applies; the choice depends on
3287 By contrast, a static pattern rule applies to the precise list of targets
3288 that you specify in the rule. It cannot apply to any other target and it
3292 The static pattern rule can be better than an implicit rule for these
3297 You may wish to override the usual implicit rule for a few
3304 might lead @code{make} to use the wrong implicit rule. The choice
3305 might depend on the order in which the implicit rule search is done.
3306 With static pattern rules, there is no uncertainty: each rule applies
3313 @cindex rule, double-colon (@code{::})
3319 ordinary rules when the same target appears in more than one rule.
3323 of them is independent of the others. Each double-colon rule's commands
3324 are executed if the target is older than any prerequisites of that rule.
3325 If there are no prerequisites for that rule, its commands are always
3330 from one another. Each double-colon rule is processed individually, just
3342 Each double-colon rule should specify commands; if it does not, an
3343 implicit rule will be used if one applies.
3362 You need this rule so that @code{make} knows that it must remake
3392 rule search. This means that @code{make} won't ever remove the file
3414 Here is the pattern rule to generate a file of prerequisites (i.e., a makefile)
3461 Once you've defined the rule to remake the @samp{.d} files,
3490 @cindex rule commands
3491 @cindex writing rule commands
3493 The commands of a rule consist of one or more shell command lines to
3495 result of executing these commands is that the target of the rule is
3530 with a tab and appears in a ``rule context'' (that is, after a rule
3531 has been started until another rule or variable definition) will be
3532 considered a command line for that rule. Blank lines and lines of
3551 A variable definition in a ``rule context'' which is indented by a tab
3557 etc. @pxref{Conditional Syntax, ,Syntax of Conditionals}) in a ``rule
3786 started with @samp{@@}. A rule in the makefile for the special target
4034 in a new shell; after the last command line is finished, the rule is
4038 the current rule, and perhaps on all rules.
4067 flag, errors are ignored in all commands of all rules. A rule in the
4234 a rule alters the effects of the @samp{-t} (@samp{--touch}), @samp{-n}
4257 line of a rule contains the variable @code{MAKE}, the flags @samp{-t},
4411 @code{make}, you can write a rule for the special target
4670 whichever rule uses the canned sequence. The output file from Yacc is
4672 rule's target file name.
4675 rule. You can substitute it like any other variable
4691 practice because @code{make} has an implicit rule to figure out these
4699 if the line appeared on its own in the rule, preceded by a tab. In
4719 a canned sequence apply to every line in the sequence. So the rule:
4862 Variable references work by strict textual substitution. Thus, the rule
5363 Several @dfn{automatic} variables are given new values for each rule.
5412 automatically to a new value for each rule; these are called the
5893 command lines will be used as the command for a rule. The result is
6123 it will be considered a command for a rule.) Aside from this, extra spaces
7207 execution of the commands for each rule
7480 programs they describe. If the first rule in the makefile has several
7481 targets, only the first target in the rule becomes the default goal, not
7534 a rule in the makefile but is not a prerequisite of the default goal.
7693 is run regardless of these options. Other lines in the same rule are
7941 Prints messages describing the implicit rule searches for each target.
8095 Rules}). But you can still define your own suffixes with a rule for
8105 Eliminate use of the built-in rule-specific variables (@pxref{Implicit
8199 @cindex implicit rule
8200 @cindex rule, implicit
8208 them. For example, there is an implicit rule for C compilation. File
8211 So @code{make} applies the implicit rule for C compilation when it sees
8222 implicit rule works. For example, the variable @code{CFLAGS} controls the
8223 flags given to the C compiler by the implicit rule for C compilation.
8241 * Using Implicit:: How to use an existing implicit rule
8249 * Suffix Rules:: The old-fashioned style of implicit rule.
8256 @cindex implicit rule, how to use
8257 @cindex rule, implicit, how to use
8261 write a rule with no command lines, or don't write a rule at all. Then
8262 @code{make} will figure out which implicit rule to use based on which
8273 Because you mention @file{foo.o} but do not give a rule for it, @code{make}
8274 will automatically look for an implicit rule that tells how to update it.
8277 If an implicit rule is found, it can supply both commands and one or
8278 more prerequisites (the source files). You would want to write a rule
8280 prerequisites, such as header files, that the implicit rule cannot
8283 Each implicit rule has a target pattern and prerequisite patterns. There may
8286 another, from a @samp{.p} file with the Pascal compiler; and so on. The rule
8292 Of course, when you write the makefile, you know which implicit rule you
8298 Above, we said an implicit rule applies if the required prerequisites ``exist
8300 the makefile as a target or a prerequisite, or if an implicit rule can be
8302 result of another implicit rule, we say that @dfn{chaining} is occurring.
8305 In general, @code{make} searches for an implicit rule for each target, and
8306 for each double-colon rule, that has no commands. A file that is mentioned
8307 only as a prerequisite is considered a target whose rule specifies nothing,
8308 so implicit rule search happens for it. @xref{Implicit Rule Search, ,Implicit Rule Search Algorith…
8311 Note that explicit prerequisites do not influence implicit rule search.
8312 For example, consider this explicit rule:
8320 @code{make} will remake @file{foo.o} according to the implicit rule to
8323 rule to make an object file from a C source file is used instead,
8324 because it appears before the Pascal rule in the list of predefined
8328 If you do not want an implicit rule to be used for a target that has no
8334 @cindex implicit rule, predefined
8335 @cindex rule, implicit, predefined
8340 canceling or overriding an implicit rule. The @samp{-r} or
8369 @cindex C, rule to compile
8378 @cindex C++, rule to compile
8389 @cindex Pascal, rule to compile
8396 @cindex Fortran, rule to compile
8397 @cindex Ratfor, rule to compile
8417 @file{@var{n}.F}. This rule runs just the preprocessor to convert a
8429 @cindex Modula-2, rule to compile
8441 @cindex assembly, rule to compile
8454 @cindex linking, predefined rule for
8461 This rule does the right thing for a simple program with only one
8500 @cindex Yacc, rule to run
8507 @cindex Lex, rule to run
8525 the list of implicit rule suffixes with:@refill
8536 @cindex @code{lint}, rule to run
8544 @cindex @TeX{}, rule to run
8545 @cindex Web, rule to run
8565 @cindex Texinfo, rule to format
8566 @cindex Info, rule to format
8580 @cindex RCS, rule to extract from
8593 @cindex SCCS, rule to extract from
8623 @code{make} follows the convention that the rule to compile a
8625 Similarly, the rule to produce an executable from a @file{.@var{x}}
8626 file uses @code{LINK.@var{x}}; and the rule to preprocess a
8630 Every rule that produces an object file uses the variable
8657 used for all C compilations performed by the implicit rule. By redefining
8865 @cindex rule, implicit, chains of
8873 how to make @file{@var{n}.c}, the rule for running Yacc is
8884 mentioned in the makefile, along with the implicit rule that says how to
8922 You can list the target pattern of an implicit rule (such as @samp{%.o})
8934 No single implicit rule can appear more than once in a chain. This means
8938 search for an implicit rule chain.
8941 otherwise be handled by rule chains. For example, making @file{foo} from
8944 actually happens is that a special rule for this case does the compilation
8945 and linking with a single @code{cc} command. The optimized rule is used in
8952 You define an implicit rule by writing a @dfn{pattern rule}. A pattern
8953 rule looks like an ordinary rule, except that its target contains the
8959 Thus, a pattern rule @samp{%.o : %.c} says how to make any file
8981 @cindex pattern rule
8982 @cindex rule, pattern
8984 A pattern rule contains the character @samp{%} (exactly one of them)
8985 in the target; otherwise, it looks exactly like an ordinary rule. The
8997 @samp{%} in a prerequisite of a pattern rule stands for the same stem
8999 pattern rule to apply, its target pattern must match the file name
9005 Thus, a rule of the form
9017 attaches to every file made by this pattern rule. These unvarying
9020 A pattern rule need not have any prerequisites that contain @samp{%}, or
9021 in fact any prerequisites at all. Such a rule is effectively a general
9028 commands. If a pattern rule has multiple targets, @code{make} knows that
9029 the rule's commands are responsible for making all of the targets. The
9031 for a pattern rule to match a target, the target patterns of a rule other
9032 than the one that matches the target in need of a rule are incidental:
9036 @cindex multiple targets, in pattern rule
9037 @cindex target, multiple in pattern rule
9043 over those that are built in. Note however, that a rule whose
9045 rule with prerequisites that must be made by chaining other implicit rules.
9053 @code{make}. First, the rule that compiles @samp{.c} files into @samp{.o}
9062 defines a rule that can make any file @file{@var{x}.o} from
9065 in each case where the rule applies (@pxref{Automatic Variables}).@refill
9067 Here is a second built-in rule:
9075 defines a rule that can make any file @file{@var{x}} whatsoever from a
9077 the target is @samp{%}, this rule will apply to any file whatever, provided
9078 the appropriate prerequisite file exists. The double colon makes the rule
9083 This pattern rule has two targets:
9110 @cindex variables, and implicit rule
9112 Suppose you are writing a pattern rule to compile a @samp{.c} file into a
9115 because the name is different each time the implicit rule is applied.
9118 variables}. These variables have values computed afresh for each rule that
9119 is executed, based on the target and prerequisites of the rule. In this
9128 within the target list of a rule; they have no value there and will
9130 within the prerequisite list of a rule. A common mistake is
9142 The file name of the target of the rule. If the target is an archive
9144 rule that has multiple targets (@pxref{Pattern Intro, ,Introduction to
9146 rule's commands to be run.
9160 an implicit rule, this will be the first prerequisite added by the
9161 implicit rule (@pxref{Implicit Rules}).
9203 The stem with which an implicit rule matches (@pxref{Pattern Match, ,How
9209 In a static pattern rule, the stem is part of the file name that matched
9212 In an explicit rule, there is no stem; so @samp{$*} cannot be determined
9221 If the target name in an explicit rule does not end with a recognized
9222 suffix, @samp{$*} is set to the empty string for that rule.
9228 This rule copies just the changed object files into the archive:
9341 @file{test.o}, the stem is @samp{test}. The pattern rule prerequisites are
9351 prerequisite file names generated from the pattern rule's prerequisite
9353 purpose of finding an implicit rule to use, not in the application of
9354 that rule. Thus, @samp{e%t} matches the file name @file{src/eat},
9364 @cindex match-anything rule
9365 @cindex terminal rule
9366 When a pattern rule's target is just @samp{%}, it matches any file name
9369 because it must consider every such rule for each file name listed either
9387 can be applied, and each time you define a match-anything rule you must
9388 choose one or the other for that rule.
9390 One choice is to mark the match-anything rule as @dfn{terminal} by defining
9391 it with a double colon. When a rule is terminal, it does not apply unless
9394 chaining is allowed beyond a terminal rule.
9404 If you do not mark the match-anything rule as terminal, then it is
9405 nonterminal. A nonterminal match-anything rule cannot apply to a file name
9407 type of data if some non-match-anything implicit rule target matches it.
9410 rule @samp{%.c : %.y} (the rule to run Yacc). Regardless of whether this
9411 rule is actually applicable (which happens only if there is a file
9427 implicit rule
9444 You can override a built-in implicit rule (or one you have defined
9445 yourself) by defining a new pattern rule with the same target and
9446 prerequisites, but different commands. When the new rule is defined, the
9447 built-in one is replaced. The new rule's position in the sequence of
9448 implicit rules is determined by where you write the new rule.
9450 You can cancel a built-in implicit rule by defining a pattern rule with the
9452 would cancel the rule that runs the assembler:
9463 You can define a last-resort implicit rule by writing a terminal
9464 match-anything pattern rule with no prerequisites (@pxref{Match-Anything
9465 Rules}). This is just like any other pattern rule; the only thing
9466 special about it is that it will match any target. So such a rule's
9468 of their own and for which no other implicit rule applies.
9485 this by writing a rule for the target @code{.DEFAULT}. Such a rule's
9487 any explicit rule, and for which no implicit rule applies. Naturally,
9488 there is no @code{.DEFAULT} rule unless you write one.
9501 pattern rule or @code{.DEFAULT}, but you also do not want any commands
9505 You can use a last-resort rule to override part of another makefile.
9511 @cindex suffix rule
9519 A double-suffix rule is defined by a pair of suffixes: the target suffix
9523 two-suffix rule whose target and source suffixes are @samp{.o} and
9524 @samp{.c} is equivalent to the pattern rule @samp{%.o : %.c}.
9526 A single-suffix rule is defined by a single suffix, which is the source
9529 rule whose source suffix is @samp{.c} is equivalent to the pattern rule
9532 Suffix rule definitions are recognized by comparing each rule's target
9533 against a defined list of known suffixes. When @code{make} sees a rule
9534 whose target is a known suffix, this rule is considered a single-suffix
9535 rule. When @code{make} sees a rule whose target is two known suffixes
9536 concatenated, this rule is taken as a double-suffix rule.
9539 known suffixes. Therefore, if you define a rule whose target is
9540 @samp{.c.o}, @code{make} takes it to be a double-suffix rule with source
9542 way to define the rule for compiling a C source file:@refill
9551 Thus, the rule:
9560 @file{foo.h}, and is not at all like the pattern rule:
9569 @samp{.o} files using this pattern rule also depend on @file{foo.h}.
9578 target @code{.SUFFIXES}. You can add your own suffixes by writing a rule
9589 to them, write a rule for @code{.SUFFIXES} with no prerequisites. By
9591 @code{.SUFFIXES}. You can then write another rule to add the suffixes you
9607 with a rule for the special target @code{.SUFFIXES}, but that does not alter
9612 @cindex implicit rule, search algorithm
9613 @cindex search algorithm, implicit rule
9615 Here is the procedure @code{make} uses for searching for an implicit rule
9617 rule with no commands, for each target of ordinary rules none of which have
9618 commands, and for each prerequisite that is not the target of any rule. It
9629 rule.@refill
9643 If any rule in that list is @emph{not} a match-anything rule, then
9650 For each pattern rule in the list:
9668 then this rule applies.
9672 If no pattern rule has been found so far, try harder.
9673 For each pattern rule in the list:
9677 If the rule is terminal, ignore it and go on to the next rule.
9688 rule.
9692 made by implicit rules, then this rule applies.
9696 If no implicit rule applies, the rule for @code{.DEFAULT}, if any,
9701 Once a rule that applies has been found, for each target pattern of the
9702 rule other than the one that matched @var{t} or @var{n}, the @samp{%} in
9709 When the commands of a pattern rule are executed for @var{t}, the automatic
9723 * Archive Update:: The implicit rule for archive member targets.
9725 * Archive Suffix Rules:: You can write a special kind of suffix rule
9747 use @code{ar}. For example, this rule says to create a member
9756 and there is an implicit rule to do it for you. @strong{Please note:} The
9787 When @code{make} looks for an implicit rule for such a target, as a special
9791 This causes one special rule whose target is @file{(%)} to match. This
9792 rule updates the target @file{@var{a}(@var{m})} by copying the file @var{m}
9797 When this rule is chained with others, the result is very powerful.
9852 Normally you would put this command in the rule for the archive file,
9853 and make all the members of the archive file prerequisites of that rule.
9865 here; most likely you can omit them and use the implicit rule which copies
9890 @cindex suffix rule, for archive
9891 @cindex archive, suffix rule for
9892 @cindex library archive, suffix rule for
9895 You can write a special kind of suffix rule for dealing with archive
9902 To write a suffix rule for archives, you simply write a suffix rule
9904 For example, here is the old-fashioned suffix rule to update a library
9917 This works just as if you had written the pattern rule:
9928 In fact, this is just what @code{make} does when it sees a suffix rule
9929 with @samp{.a} as the target suffix. Any double-suffix rule
9930 @w{@samp{.@var{x}.a}} is converted to a pattern rule with the target
9935 in the normal way (@pxref{Suffix Rules}). Thus a double-suffix rule
10001 general feature of rule chaining (@pxref{Chained Rules, ,Chains of
10002 Implicit Rules}) allows one pattern rule for installing members in an
10216 suffix rule @samp{.c~.o} would make the file @file{@var{n}.o} from
10223 general feature of rule chaining.
10234 the prerequisites of a rule has the amazingly strange ``feature'' of
10235 expanding to the full name of the @emph{target of that rule}. We cannot
10241 In some Unix @code{make}s, implicit rule search
10267 It appears that in SVR4 @code{make}, a suffix rule can be specified with
10276 will override the built-in @file{.c.a} suffix rule.
10278 We feel that it is cleaner for a rule without commands to always simply
10553 The stem with which an implicit rule matches
10687 but the rule in the makefile was prefixed with the @code{-} special
10707 @itemx missing rule before commands. Stop.
10715 out the "target: prerequisite" section of a rule. @xref{Rule Syntax}.
10717 @item No rule to make target `@var{xxx}'.
10718 @itemx No rule to make target `@var{xxx}', needed by `@var{yyy}'.
10723 If you want that file to be built, you will need to add a rule to your
10777 there's no pattern in the target section of the rule; the second means
10780 fourth means that all three parts of the static pattern rule contain
10796 @item warning: jobserver unavailable: using -j1. Add `+' to parent make rule.