convert byte array to pdf mvc : Convert pdf to web link SDK application API wpf windows web page sharepoint make12-part1913

Chapter 10: Using Implicit Rules
111
10 Using Implicit Rules
Certain standard ways of remaking target files are used very often. For example, one
customary way to make an object file is from a C source file using the C compiler, cc.
Implicit rules tell make how to use customary techniques so that you do not have to
specify them in detail when you want to use them. For example, there is an implicit rule
for C compilation. File names determine which implicit rules are run. For example, C
compilation typically takes a .c file and makes a .o file. So make applies the implicit rule
for C compilation when it sees this combination of file name endings.
Achain of implicit rules can apply in sequence; for example, make will remake a .o file
from a .y file by way of a .c file. SeeSection10.4[ChainsofImplicitRules],page117.
The built-in implicit rules use several variables in their recipes so that, by changing
the values of the variables, you can change the way the implicit rule works. For example,
the variable CFLAGS controls the flags given to the C compiler by the implicit rule for C
compilation. SeeSection10.3[VariablesUsedbyImplicitRules],page115.
Youcandefine your ownimplicitrules by writing patternrules. SeeSection10.5[Defining
and Redefining Pattern Rules], page 118.
Suffix rules are a more limited way to define implicit rules. Pattern rules are more general
and clearer, but suffix rules are retained for compatibility. SeeSection10.7[Old-Fashioned
Suffix Rules], page 125.
10.1 Using Implicit Rules
To allow make to find a customary method for updating a target file, all you have to do is
refrain from specifying recipes yourself. Either write a rule with no recipe, or don’t write
arule at all. Then make will figure out which implicit rule to use based on which kind of
source file exists or can be made.
For example, suppose the makefile looks like this:
foo : foo.o bar.o
cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)
Because you mention foo.o but do not give a rule for it, make will automatically look for
an implicit rule that tells how to update it. This happens whether or not the file foo.o
currently exists.
If an implicit rule is found, it can supply both a recipe and one or more prerequisites
(the source files). You would want to write a rule for foo.o with no recipe if you need to
specify additional prerequisites, such as header files, that the implicit rule cannot supply.
Each implicit rule has a target pattern and prerequisite patterns. There may be many
implicit rules with the same target pattern. For example, numerous rules make ‘.o’ files:
one, from a ‘.c’ file with the C compiler; another, from a ‘.p’ file with the Pascal compiler;
and so on. The rule that actually applies is the one whose prerequisites exist or can be
made. So, if you have a file foo.c, make will run the C compiler; otherwise, if you have a
file foo.p, make will run the Pascal compiler; and so on.
Of course, when you write the makefile, you know which implicit rule you want make
to use, and you know it will choose that one because you know which possible prerequisite
Convert pdf to web link - software Library project:C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net, ASP.NET MVC, WinForms, WPF application
How to Convert PDF to HTML Webpage with C# PDF Conversion SDK
www.rasteredge.com
Convert pdf to web link - software Library project:VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.net, ASP.NET MVC, WinForms, WPF application
PDF to HTML Webpage Converter SDK for VB.NET PDF to HTML Conversion
www.rasteredge.com
112
GNU make
files are supposed to exist. SeeSection10.2[CatalogueofBuilt-InRules],page112, for a
catalogue of all the predefined implicit rules.
Above, we said an implicit rule applies if the required prerequisites “exist or can be
made”. A file “can be made” if it is mentioned explicitly in the makefile as a target or a
prerequisite, or if an implicit rule can be recursively found for how to make it. When an
implicit prerequisite is the result of another implicit rule, we say that chaining is occurring.
SeeSection10.4[ChainsofImplicitRules],page117.
In general, make searches for an implicit rule for each target, and for each double-colon
rule, that has no recipe. A file that is mentioned only as a prerequisite is considered a
target whose rule specifies nothing, so implicit rule search happens for it. SeeSection10.8
[Implicit Rule Search Algorithm], page 127,forthedetailsofhowthesearchisdone.
Note that explicit prerequisites do not influence implicit rule search. For example, con-
sider this explicit rule:
foo.o: foo.p
The prerequisite on foo.p does not necessarily mean that make willremake foo.o according
to the implicit rule to make an object file, a .o file, from a Pascal source file, a .p file. For
example, if foo.c also exists, the implicit rule to make an object file from a C source file
is used instead, because it appears before the Pascal rule in the list of predefined implicit
rules (seeSection10.2[CatalogueofBuilt-InRules],page112).
If you do not want an implicit rule to be used for a target that has no recipe, you can
give that target an empty recipe by writing a semicolon (seeSection5.9[DefiningEmpty
Recipes], page 57).
10.2 Catalogue of Built-In Rules
Here is a catalogue of predefined implicit rules which are always available unless the
makefile explicitly overrides or cancels them. See Section 10.5.6 [Canceling Implicit
Rules], page 124,for informationoncancelingor overridinganimplicit rule. . The e ‘-r’or
‘--no-builtin-rules’ option cancels all predefined rules.
This manual only documents the default rules available on POSIX-based operating sys-
tems. Other operating systems, such as VMS, Windows, OS/2, etc. may have different sets
of default rules. To see the full list of default rules and variables available in your version
of GNU make, run ‘make -p’ in a directory with no makefile.
Not all of these rules will always be defined, even when the ‘-r’ option is not given.
Many of the predefined implicit rules are implemented in make as suffix rules, so which
ones will be defined depends on the suffix list (the list of prerequisites of the special target
.SUFFIXES). The default suffix list is: .out, .a, .ln, .o, .c, .cc, .C, .cpp, .p, .f, .F, .m,
.r, .y, .l, .ym, .lm, .s, .S, .mod, .sym, .def, .h, .info, .dvi, .tex, .texinfo, .texi,
.txinfo, .w, .ch .web, .sh, .elc, .el. All of the implicit rules described below whose
prerequisites have one of these suffixes are actually suffix rules. If you modify the suffix list,
the only predefined suffix rules in effect will be those named by one or two of the suffixes
that are on the list you specify; rules whose suffixes fail to be on the list are disabled. See
Section 10.7 [Old-Fashioned Suffix Rules], page 125,forfulldetailsonsuffixrules.
Compiling C programs
n.o is made automatically from n.c with a recipe of the form ‘$(CC)
$(CPPFLAGS) $(CFLAGS) -c’.
software Library project:C#: How to Add HTML5 Document Viewer Control to Your Web Page
the necessary resources for creating web document viewer addCommand(new RECommand("convert")); _tabFile.addCommand new UserCommand("pdf"); _userCmdDemoPdf.
www.rasteredge.com
software Library project:C# Image: How to Integrate Web Document and Image Viewer
RasterEdge DocImage SDK for .NET link directly. project for building a modern web document image RasterEdgeImagingDeveloperGuide8.0.pdf: from this user manual
www.rasteredge.com
Chapter 10: Using Implicit Rules
113
Compiling C++ programs
n.o is made automatically from n.cc, n.cpp, or n.C with a recipe of the form
‘$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c’. We encourage you to use the suffix
‘.cc’ for C++ source files instead of ‘.C’.
Compiling Pascal programs
n.o is made automatically from n.p with the recipe ‘$(PC) $(PFLAGS) -c’.
Compiling Fortran and Ratfor programs
n.o is made automatically from n.r, n.F or n.f by running the Fortran com-
piler. The precise recipe used is as follows:
‘.f’
‘$(FC) $(FFLAGS) -c’.
‘.F’
‘$(FC) $(FFLAGS) $(CPPFLAGS) -c’.
‘.r’
‘$(FC) $(FFLAGS) $(RFLAGS) -c’.
Preprocessing Fortran and Ratfor programs
n.f is made automatically from n.r or n.F. This rule runs just the preprocessor
to convert a Ratfor or preprocessable Fortran program into a strict Fortran
program. The precise recipe used is as follows:
‘.F’
‘$(FC) $(CPPFLAGS) $(FFLAGS) -F’.
‘.r’
‘$(FC) $(FFLAGS) $(RFLAGS) -F’.
Compiling Modula-2 programs
n.sym is made from
n.def with a recipe of the form
‘$(M2C)
$(M2FLAGS) $(DEFFLAGS)’.
n.o is made from n.mod; the form is:
‘$(M2C) $(M2FLAGS) $(MODFLAGS)’.
Assembling and preprocessing assembler programs
n.o is made automatically from n.s by running the assembler, as. The precise
recipe is ‘$(AS) $(ASFLAGS)’.
n.s is made automatically from n.S by running the C preprocessor, cpp. The
precise recipe is ‘$(CPP) $(CPPFLAGS)’.
Linking a single object file
n is made automatically from
n.o by running the linker (usu-
ally called ld) via the C compiler.
The precise recipe used is
‘$(CC) $(LDFLAGS) n.o $(LOADLIBES) $(LDLIBS)’.
This rule does the right thing for a simple program with only one source file. It
will also do the right thing if there are multiple object files (presumably coming
from various other source files), one of which has a name matching that of the
executable file. Thus,
x: y.o z.o
when x.c, y.c and z.c all exist will execute:
software Library project:VB.NET PDF: Create PDF Document Viewer in C#.NET for Document
reading PDF document in ASP.NET web, .NET Windows Forms and mobile developing applications respectively. For more information on them, just click the link and
www.rasteredge.com
software Library project:C# PDF: How to Create PDF Document Viewer in C#.NET with
Support rendering web viewer PDF document to images or svg file; Free to convert viewing PDF document to TIFF file for document management;
www.rasteredge.com
114
GNU make
cc -c x.c -o x.o
cc -c y.c -o y.o
cc -c z.c -o z.o
cc x.o y.o z.o -o x
rm -f x.o
rm -f y.o
rm -f z.o
In more complicated cases, such as when there is no object file whose name
derives from the executable file name, you must write an explicit recipe for
linking.
Each kind of file automatically made into ‘.o’ object files will be automatically
linkedby usingthe compiler (‘$(CC)’,‘$(FC)’or ‘$(PC)’; the C compiler ‘$(CC)’
is used to assemble ‘.s’ files) without the ‘-c’ option. This could be done by
using the ‘.o’ object files as intermediates, but it is faster to do the compiling
and linking in one step, so that’s how it’s done.
Yacc for C programs
n.c is made automatically from n.y by running Yacc with the recipe ‘$(YACC)
$(YFLAGS)’.
Lex for C programs
n.c is made automatically from n.l by running Lex. The actual recipe is
‘$(LEX) $(LFLAGS)’.
Lex for Ratfor programs
n.r is made automatically from n.l by running Lex. The actual recipe is
‘$(LEX) $(LFLAGS)’.
The conventionofusing the samesuffix ‘.l’for all Lex files regardless of whether
they produce C code or Ratfor code makes it impossible for make to determine
automatically whichofthe two languages youare using inany particular case. If
make is called upon to remake an object file from a ‘.l’ file, it must guess which
compiler to use. It will guess the C compiler, because that is more common.
If you are using Ratfor, make sure make knows this by mentioning n.r in the
makefile. Or, if you are using Ratfor exclusively, with no C files, remove ‘.c’
from the list of implicit rule suffixes with:
.SUFFIXES:
.SUFFIXES: .o .r .f .l ...
Making Lint Libraries from C, Yacc, or Lex programs
n.ln is made from n.c by running lint.
The precise recipe is
‘$(LINT) $(LINTFLAGS) $(CPPFLAGS) -i’. The same recipe is used on the C
code produced from n.y or n.l.
T
E
Xand Web
n.dvi is made from n.tex with the recipe ‘$(TEX)’. n.tex is made from n.web
with ‘$(WEAVE)’, or from n.w (and from n.ch if it exists or can be made) with
‘$(CWEAVE)’. n.p is made from n.web with ‘$(TANGLE)’ and n.c is made from
n.w (and from n.ch if it exists or can be made) with ‘$(CTANGLE)’.
software Library project:VB.NET Image: VB Code to Download and Save Image from Web URL
users to download image from website link more easily. Apart from image downloading from web URL, RasterEdge & profession imaging controls, PDF document, image
www.rasteredge.com
software Library project:C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
In some situations, it is quite necessary to convert PDF document into SVG image format. indexed, scripted, and supported by most of the up to date web browsers
www.rasteredge.com
Chapter 10: Using Implicit Rules
115
Texinfo and Info
n.dvi is made from n.texinfo, n.texi, or n.txinfo, with the recipe
‘$(TEXI2DVI) $(TEXI2DVI_FLAGS)’. n.info is made from n.texinfo, n.texi,
or n.txinfo, with the recipe ‘$(MAKEINFO) $(MAKEINFO_FLAGS)’.
RCS
Any file n is extracted if necessary from an RCS file named either n,v or
RCS/n,v. The precise recipe used is ‘$(CO) $(COFLAGS)’. n will not be ex-
tracted from RCS if it already exists, even if the RCS file is newer. The
rules for RCS are terminal (seeSection10.5.5[Match-AnythingPatternRules],
page 123), so RCSfiles s cannotbegeneratedfromanothersource; ; theymust
actually exist.
SCCS
Any file n is extracted if necessary from an SCCS file named either s.n or
SCCS/s.n. The precise recipe used is ‘$(GET) $(GFLAGS)’. The rules for SCCS
are terminal (seeSection10.5.5[Match-AnythingPatternRules],page123), so
SCCS files cannot be generated from another source; they must actually exist.
For the benefit of SCCS, a file n is copied from n.sh and made executable
(by everyone). This is for shell scripts that are checked into SCCS. Since RCS
preserves the execution permission of a file, you do not need to use this feature
with RCS.
Werecommend that you avoidusing of SCCS. RCSis widely heldto be superior,
and is also free. By choosing free software in place of comparable (or inferior)
proprietary software, you support the free software movement.
Usually, you want to change only the variables listed in the table above, which are
documented in the following section.
However, the recipes in built-in implicit rules actually use variables such as COMPILE.c,
LINK.p, and PREPROCESS.S, whose values contain the recipes listed above.
make follows the convention that the rule to compile a .x source file uses the variable
COMPILE.x. Similarly, the rule to produce an executable from a .x file uses LINK.x; and
the rule to preprocess a .x file uses PREPROCESS.x.
Every rule that produces an object file uses the variable OUTPUT_OPTION. make defines
this variable either to contain ‘-o $@’, or to be empty, depending on a compile-time option.
You need the ‘-o’ option to ensure that the output goes into the right file when the source
file is in a different directory, as when using VPATH (see Section 4.4 [Directory y Search],
page 25). However,compilersonsomesystemsdonotaccepta‘-o’switchforobjectfiles.
If you use such a system, and use VPATH, some compilations will put their output in the
wrong place. A possible workaround for this problem is to give OUTPUT_OPTION the value
‘; mv $*.o $@’.
10.3 Variables Used by Implicit Rules
The recipes in built-in implicit rules make liberal use of certain predefined variables. You
can alter the values of these variables in the makefile, with arguments to make, or in the en-
vironment to alter how the implicit rules work without redefining the rules themselves. You
can cancel all variables used by implicit rules with the ‘-R’ or ‘--no-builtin-variables’
option.
software Library project:C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
and quickly convert a large-size multi-page PDF document to a group of high-quality separate JPEG image files within .NET projects, including ASP.NET web and
www.rasteredge.com
software Library project:VB.NET Image: Tutorial for Converting Image and Document in VB.NET
Use VB.NET Code to Convert Image to Stream, PDF to Image Conversion Through VB Programming. To convert image in web application, you may use our ASP.NET image
www.rasteredge.com
116
GNU make
For example, therecipeusedtocompile aC source file actuallysays ‘$(CC) -c $(CFLAGS)
$(CPPFLAGS)’. The default values of the variables used are ‘cc’ and nothing, resulting in
the command ‘cc -c’. By redefining ‘CC’ to ‘ncc’, you could cause ‘ncc’ to be used for
all C compilations performed by the implicit rule. By redefining ‘CFLAGS’ to be ‘-g’, you
could pass the ‘-g’ option to each compilation. All implicit rules that do C compilation use
‘$(CC)’ to get the program name for the compiler and all include ‘$(CFLAGS)’ among the
arguments given to the compiler.
The variables usedin implicit rules fallinto twoclasses: those that are names of programs
(like CC) and those that contain arguments for the programs (like CFLAGS). (The “name of
aprogram” may also contain some command arguments, but it must start with an actual
executable program name.) If a variable value contains more than one argument, separate
them with spaces.
The following tables describe of some of the more commonly-used predefined variables.
This list is not exhaustive, and the default values shown here may not be what make selects
for your environment. To see the complete list of predefined variables for your instance of
GNU make you can run ‘make -p’ in a directory with no makefiles.
Here is a table of some of the more common variables used as names of programs in
built-in rules:
AR
Archive-maintaining program; default ‘ar’.
AS
Program for compiling assembly files; default ‘as’.
CC
Program for compiling C programs; default ‘cc’.
CXX
Program for compiling C++ programs; default ‘g++’.
CPP
Program for running the C preprocessor, with results to standard output; de-
fault ‘$(CC) -E’.
FC
Program for compiling or preprocessing Fortran and Ratfor programs; default
‘f77’.
M2C
Program to use to compile Modula-2 source code; default ‘m2c’.
PC
Program for compiling Pascal programs; default ‘pc’.
CO
Program for extracting a file from RCS; default ‘co’.
GET
Program for extracting a file from SCCS; default ‘get’.
LEX
Program to use to turn Lex grammars into source code; default ‘lex’.
YACC
Program to use to turn Yacc grammars into source code; default ‘yacc’.
LINT
Program to use to run lint on source code; default ‘lint’.
MAKEINFO Program to convert a Texinfo source file into an Info file; default ‘makeinfo’.
TEX
Program to make T
E
Xdvi files from T
E
Xsource; default ‘tex’.
TEXI2DVI Program to make T
E
Xdvi files from Texinfo source; default ‘texi2dvi’.
WEAVE
Program to translate Web into T
E
X; default ‘weave’.
CWEAVE
Program to translate C Web into T
E
X; default ‘cweave’.
software Library project:VB.NET Word: VB Code to Create Word Mobile Viewer with .NET Doc
Directly convert your Android, iOS or Windows mobile device into a Process Word web page(s) within a few steps like png, gif, bmp, jpeg, tiff, pdf, and dicom.
www.rasteredge.com
Chapter 10: Using Implicit Rules
117
TANGLE
Program to translate Web into Pascal; default ‘tangle’.
CTANGLE
Program to translate C Web into C; default ‘ctangle’.
RM
Command to remove a file; default ‘rm -f’.
Here is a table of variables whose values are additional arguments for the programs
above. The default values for all of these is the empty string, unless otherwise noted.
ARFLAGS
Flags to give the archive-maintaining program; default ‘rv’.
ASFLAGS
Extra flags to give to the assembler (when explicitly invoked on a ‘.s’ or ‘.S’
file).
CFLAGS
Extra flags to give to the C compiler.
CXXFLAGS Extra flags to give to the C++ compiler.
COFLAGS
Extra flags to give to the RCS co program.
CPPFLAGS Extra flags to give to the C preprocessor and programs that use it (the C and
Fortran compilers).
FFLAGS
Extra flags to give to the Fortran compiler.
GFLAGS
Extra flags to give to the SCCS get program.
LDFLAGS
Extra flags to give to compilers when they are supposed to invoke the linker,
‘ld’, such as -L. Libraries (-lfoo) should be added to the LDLIBS variable
instead.
LDLIBS
Library flags or names given to compilers when they are supposed to invoke
the linker, ‘ld’. LOADLIBES is a deprecated (but still supported) alternative to
LDLIBS. Non-library linker flags, such as -L, should go in the LDFLAGS variable.
LFLAGS
Extra flags to give to Lex.
YFLAGS
Extra flags to give to Yacc.
PFLAGS
Extra flags to give to the Pascal compiler.
RFLAGS
Extra flags to give to the Fortran compiler for Ratfor programs.
LINTFLAGS
Extra flags to give to lint.
10.4 Chains of Implicit Rules
Sometimes a file can be made by a sequence of implicit rules. For example, a file n.o could
be made from n.y by running first Yacc and then cc. Such a sequence is called a chain.
If the file n.c exists, or is mentioned in the makefile, no special searching is required:
make finds that the object file can be made by C compilation from n.c; later on, when
considering how to make n.c, the rule for running Yacc is used. Ultimately both n.c and
n.o are updated.
However, even if n.c does not exist and is not mentioned, make knows how to envision
it as the missing link between n.o and n.y! In this case, n.c is called an intermediate file.
118
GNU make
Once make has decided to use the intermediate file, it is entered in the data base as if it had
been mentioned in the makefile, along with the implicit rule that says how to create it.
Intermediate files are remade using their rules just like all other files. But intermediate
files are treated differently in two ways.
The first difference is what happens if the intermediate file does not exist. If an ordinary
file b does not exist, and make considers a target that depends on b, it invariably creates b
and then updates the target from b. But if b is an intermediate file, then make canleave well
enough alone. It won’t bother updating b, or the ultimate target, unless some prerequisite
of b is newer than that target or there is some other reason to update that target.
The second difference is that if make does create b in order to update something else,
it deletes b later on after it is no longer needed. Therefore, an intermediate file which did
not exist before make also does not exist after make. make reports the deletion to you by
printing a ‘rm -f’ command showing which file it is deleting.
Ordinarily, a file cannot be intermediate if it is mentioned in the makefile as a target
or prerequisite. However, you can explicitly mark a file as intermediate by listing it as
a prerequisite of the special target .INTERMEDIATE. This takes effect even if the file is
mentioned explicitly in some other way.
You can prevent automatic deletion of an intermediate file by marking it as a secondary
file. To do this, list it as a prerequisite of the special target .SECONDARY. When a file
is secondary, make will not create the file merely because it does not already exist, but
make does not automatically delete the file. Marking a file as secondary also marks it as
intermediate.
You can list the target pattern of an implicit rule (such as ‘%.o’) as a prerequisite of the
special target .PRECIOUS to preserve intermediate files made by implicit rules whose target
patterns match that file’s name; seeSection5.6[Interrupts],page50.
Achain can involve more than two implicit rules. For example, it is possible to make a
file foo from RCS/foo.y,v by running RCS, Yacc and cc. Then both foo.y and foo.c are
intermediate files that are deleted at the end.
No single implicit rule can appear more than once in a chain. This means that make
will not even consider such a ridiculous thing as making foo from foo.o.o by running the
linker twice. This constraint has the added benefit of preventing any infinite loop in the
search for an implicit rule chain.
There are some special implicit rules to optimize certain cases that would otherwise
be handled by rule chains. For example, making foo from foo.c could be handled by
compiling and linking with separate chained rules, using foo.o as an intermediate file. But
what actually happens is that a special rule for this case does the compilation and linking
with a single cc command. The optimized rule is used in preference to the step-by-step
chain because it comes earlier in the ordering of rules.
10.5 Defining and Redefining Pattern Rules
You define an implicit rule by writing a pattern rule. A pattern rule looks like an ordinary
rule, except that its target contains the character ‘%’ (exactly one of them). The target is
considered a pattern for matching file names; the ‘%’ can match any nonempty substring,
while other characters match only themselves. The prerequisites likewise use ‘%’ to show
how their names relate to the target name.
Chapter 10: Using Implicit Rules
119
Thus, a pattern rule ‘%.o : %.c’ says how to make any file stem.o from another file
stem.c.
Note that expansion using ‘%’ in pattern rules occurs after any variable or function ex-
pansions, which take place when the makefile is read. SeeChapter6[HowtoUseVariables],
page 59,and Chapter 8 [Functions for Transforming Text], page 83.
10.5.1 Introduction to Pattern Rules
Apattern rule contains the character ‘%’ (exactly one of them) in the target; otherwise, it
looks exactly like an ordinary rule. The target is a pattern for matching file names; the ‘%’
matches any nonempty substring, while other characters match only themselves.
For example, ‘%.c’ as a pattern matches any file name that ends in ‘.c’. ‘s.%.c’ as
a pattern matches any file name that starts with ‘s.’, ends in ‘.c’ and is at least five
characters long. (There must be at least one character to match the ‘%’.) The substring
that the ‘%’ matches is called the stem.
‘%’ in a prerequisite of a pattern rule stands for the same stem that was matched by the
‘%’ in the target. In order for the pattern rule to apply, its target pattern must match the
file name under consideration and all of its prerequisites (after pattern substitution) must
name files that exist or can be made. These files become prerequisites of the target.
Thus, a rule of the form
%.o : %.c ; recipe...
specifies how to make a file n.o, with another file n.c as its prerequisite, provided that n.c
exists or can be made.
There may also be prerequisites that do not use ‘%’; such a prerequisite attaches to every
file made by this pattern rule. These unvarying prerequisites are useful occasionally.
Apattern rule need not have any prerequisites that contain ‘%’, or in fact any prerequi-
sites at all. Such a rule is effectively a general wildcard. It provides a way to make any file
that matches the target pattern. SeeSection10.6[LastResort],page125.
More than one pattern rule may match a target. In this case make will choose the “best
fit” rule. SeeSection10.5.4[HowPatternsMatch],page122.
Pattern rules may have more than one target. Unlike normal rules, this does not act as
many different rules with the same prerequisites and recipe. If a pattern rule has multiple
targets, make knows that the rule’s recipe is responsible for making all of the targets. The
recipe is executed only once to make all the targets. When searching for a pattern rule to
match a target, the target patterns of a rule other than the one that matches the target in
need of a rule are incidental: make worries only about giving a recipe and prerequisites to
the file presently in question. However, when this file’s recipe is run, the other targets are
marked as having been updated themselves.
10.5.2 Pattern Rule Examples
Here are some examples of pattern rules actually predefined in make. First, the rule that
compiles ‘.c’ files into ‘.o’ files:
%.o : %.c
$(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@
120
GNU make
defines a rule that can make any file x.o from x.c. The recipe uses the automatic variables
‘$@’ and ‘$<’ to substitute the names of the target file and the source file in each case where
the rule applies (seeSection10.5.3[AutomaticVariables],page120).
Here is a second built-in rule:
% :: RCS/%,v
$(CO) $(COFLAGS) $<
defines a rule that can make any file x whatsoever from a corresponding file x,v in the sub-
directory RCS. Since the target is ‘%’, this rule will apply to any file whatever, provided the
appropriate prerequisite file exists. The double colon makes the rule terminal, which means
that its prerequisite may not be an intermediate file (see Section10.5.5[Match-Anything
Pattern Rules], page 123).
This pattern rule has two targets:
%.tab.c %.tab.h: %.y
bison -d $<
This tells make that the recipe ‘bison -d x.y’ will make both x.tab.c and x.tab.h. If
the file foo depends on the files parse.tab.o and scan.o and the file scan.o depends
on the file parse.tab.h, when parse.y is changed, the recipe ‘bison -d parse.y’ will be
executed only once, and the prerequisites of both parse.tab.o and scan.o will be satisfied.
(Presumably the file parse.tab.o will be recompiled from parse.tab.c and the file scan.o
from scan.c, while foo is linked from parse.tab.o, scan.o, and its other prerequisites,
and it will execute happily ever after.)
10.5.3 Automatic Variables
Suppose you are writing a pattern rule to compile a ‘.c’ file into a ‘.o’ file: how do you
write the ‘cc’ command so that it operates on the right source file name? You cannot write
the name in the recipe, because the name is different each time the implicit rule is applied.
What you do is use a special feature of make, the automatic variables. These variables
have values computed afresh for each rule that is executed, based on the target and prereq-
uisites of the rule. In this example, you would use ‘$@’ for the object file name and ‘$<’ for
the source file name.
It’s very important that you recognize the limited scope in which automatic variable
values are available: they only have values within the recipe. In particular, you cannot use
them anywhere within the target list of a rule; they have no value there and will expand
to the empty string. Also, they cannot be accessed directly within the prerequisite list
of a rule. A common mistake is attempting to use $@ within the prerequisites list; this
will not work. However, there is a special feature of GNU make, secondary expansion (see
Section 3.8 [Secondary Expansion], page 18),whichwillallowautomaticvariablevaluesto
be used in prerequisite lists.
Here is a table of automatic variables:
$@
The file name of the target of the rule. If the target is an archive member, then
‘$@’ is the name of the archive file. In a pattern rule that has multiple targets
(seeSection10.5.1[IntroductiontoPatternRules],page119), ‘$@’ is the name
of whichever target caused the rule’s recipe to be run.
Documents you may be interested
Documents you may be interested