convert byte array to pdf mvc : Convert pdf form to html SDK Library service wpf asp.net azure dnn make4-part1941

Chapter 4: Writing Rules
31
cleanall : cleanobj cleandiff
rm program
cleanobj :
rm *.o
cleandiff :
rm *.diff
4.6 Rules without Recipes or Prerequisites
If a rule has no prerequisites or recipe, and the target of the rule is a nonexistent file, then
make imagines this target to have been updated whenever its rule is run. This implies that
all targets depending on this one will always have their recipe run.
An example will illustrate this:
clean: FORCE
rm $(objects)
FORCE:
Here the target ‘FORCE’ satisfies the special conditions, so the target clean that depends
on it is forced to run its recipe. There is nothing special about the name ‘FORCE’, but that
is one name commonly used this way.
As you can see, using ‘FORCE’ this way has the same results as using ‘.PHONY: clean’.
Using ‘.PHONY’ is more explicit and more efficient. However, other versions of make do
not support ‘.PHONY’; thus ‘FORCE’ appears in many makefiles. See Section 4.5 [Phony
Targets], page 29.
4.7 Empty Target Files to Record Events
The empty target is a variant of the phony target; it is used to hold recipes for an action
that you request explicitly from time to time. Unlike a phony target, this target file can
really exist; but the file’s contents do not matter, and usually are empty.
The purpose of the empty target file is to record, with its last-modification time, when
the rule’s recipe was last executed. It does so because one of the commands in the recipe
is a touch command to update the target file.
The empty target file should have some prerequisites (otherwise it doesn’t make sense).
When you ask to remake the empty target, the recipe is executed if any prerequisite is more
recent than the target; in other words, if a prerequisite has changed since the last time you
remade the target. Here is an example:
print: foo.c bar.c
lpr -p $?
touch print
With this rule, ‘make print’ will execute the lpr command if either source file has changed
since the last ‘make print’. The automatic variable ‘$?’ is used to print only those files
that have changed (seeSection10.5.3[AutomaticVariables],page120).
Convert pdf form to html - control SDK platform: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 form to html - control SDK platform: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
32
GNU make
4.8 Special Built-in Target Names
Certain names have special meanings if they appear as targets.
.PHONY
The prerequisites of the special target .PHONY are considered to be phony tar-
gets. When it is time to consider such a target, make will run its recipe un-
conditionally, regardless of whether a file with that name exists or what its
last-modification time is. SeeSection4.5[PhonyTargets],page29.
.SUFFIXES
The prerequisites of the special target .SUFFIXES are the list of suffixes to be
used in checking for suffix rules. SeeSection10.7[Old-FashionedSuffixRules],
page 125.
.DEFAULT
The recipe specified for .DEFAULT is used for any target for which no rules are
found (either explicit rules or implicit rules). See Section10.6 [LastResort],
page 125.Ifa.DEFAULTrecipeisspecified,everyfilementionedasaprerequi-
site, but not as a target in a rule, will have that recipe executed on its behalf.
SeeSection10.8[ImplicitRuleSearchAlgorithm],page127.
.PRECIOUS
The targets which .PRECIOUS depends on are given the following special treat-
ment: if make is killed or interrupted during the execution of their recipes, the
target is not deleted. See Section5.6[InterruptingorKillingmake],page50.
Also, if the target is an intermediate file, it will not be deleted after it is no
longer needed, as is normally done. SeeSection10.4[ChainsofImplicitRules],
page 117. Inthislatterrespectitoverlapswiththe.SECONDARYspecialtarget.
You can also list the target pattern of an implicit rule (such as ‘%.o’) as a
prerequisite file of the special target .PRECIOUS to preserve intermediate files
created by rules whose target patterns match that file’s name.
.INTERMEDIATE
The targets which .INTERMEDIATE depends on are treated as intermediate files.
SeeSection10.4[ChainsofImplicitRules],page117. .INTERMEDIATE with no
prerequisites has no effect.
.SECONDARY
The targets which .SECONDARY depends on are treated as intermediate files,
except that they are never automatically deleted. SeeSection10.4[Chainsof
Implicit Rules], page 117.
.SECONDARY with no prerequisites causes all targets to be treated as secondary
(i.e., no target is removed because it is considered intermediate).
.SECONDEXPANSION
If .SECONDEXPANSION is mentioned as a target anywhere in the makefile, then
all prerequisite lists defined after it appears will be expanded a second time
after all makefiles have been read in. SeeSection3.8[Secondary Expansion],
page 18.
control SDK platform:VB.NET PDF Form Data Read library: extract form data from PDF in
RasterEdge .NET PDF SDK is such one provide various of form field edit functions. Demo Code to Retrieve All Form Fields from a PDF File in VB.NET.
www.rasteredge.com
control SDK platform:C# PDF Form Data Read Library: extract form data from PDF in C#.
A best PDF document SDK library enable users abilities to read and extract PDF form data in Visual C#.NET WinForm and ASP.NET WebForm applications.
www.rasteredge.com
Chapter 4: Writing Rules
33
.DELETE_ON_ERROR
If .DELETE_ON_ERROR is mentioned as a target anywhere in the makefile, then
make will delete the target of a rule if it has changed and its recipe exits with
anonzero exit status, just as it does when it receives a signal. SeeSection5.5
[Errors in Recipes], page 49.
.IGNORE
If you specify prerequisites for .IGNORE,then make willignoreerrors in execution
of the recipe for those particular files. The recipe for .IGNORE (if any) is ignored.
If mentioned as a target with no prerequisites, .IGNORE says to ignore errors in
execution of recipes for all files. This usage of ‘.IGNORE’ is supported only for
historical compatibility. Since this affects every recipe in the makefile, it is not
very useful; we recommend you use the more selective ways to ignore errors in
specific recipes. SeeSection5.5[ErrorsinRecipes],page49.
.LOW_RESOLUTION_TIME
If you specify prerequisites for .LOW_RESOLUTION_TIME, make assumes that
these files are created by commands that generate low resolution time stamps.
The recipe for the .LOW_RESOLUTION_TIME target are ignored.
The high resolution file time stamps of many modern file systems lessen the
chance of make incorrectly concluding that a file is up to date. Unfortunately,
some hosts do not provide a way to set a high resolution file time stamp, so
commands like ‘cp -p’ that explicitly set a file’s time stamp must discard its
sub-second part. If a file is created by such a command, you should list it
as a prerequisite of .LOW_RESOLUTION_TIME so that make does not mistakenly
conclude that the file is out of date. For example:
.LOW_RESOLUTION_TIME: dst
dst: src
cp -p src dst
Since ‘cp -p’ discards the sub-second part of src’s time stamp, dst is typically
slightly older than src even when it is up to date. The .LOW_RESOLUTION_TIME
line causes make to consider dst to be up to date if its time stamp is at the
start of the same second that src’s time stamp is in.
Due to a limitation of the archive format, archive member time stamps are
always low resolution. You need not list archive members as prerequisites of
.LOW_RESOLUTION_TIME, as make does this automatically.
.SILENT
If you specify prerequisites for .SILENT, then make will not print the recipe used
to remake those particular files before executing them. The recipe for .SILENT
is ignored.
If mentioned as a target with no prerequisites, .SILENT says not to print any
recipes before executing them. This usage of ‘.SILENT’ is supported only for
historical compatibility. We recommend you use the more selective ways to
silence specific recipes. SeeSection5.2[RecipeEchoing],page43. If you want
to silence all recipes for a particular run of make, use the ‘-s’ or ‘--silent’
option (seeSection9.7[OptionsSummary],page104).
control SDK platform:VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
C#: Convert PDF to HTML; C#: Convert PDF to Jpeg; C# File: Compress PDF; C# File: Merge PDF; C# Protect: Add Password to PDF; C# Form: extract value from fields;
www.rasteredge.com
control SDK platform:C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
C# PDF - Convert PDF to JPEG in C#.NET. C#.NET PDF to JPEG Converting & Conversion Control. Convert PDF to JPEG Using C#.NET. Add necessary references:
www.rasteredge.com
34
GNU make
.EXPORT_ALL_VARIABLES
Simply by being mentioned as a target, this tells make to export all variables
to child processes by default. SeeSection5.7.2[CommunicatingVariablestoa
Sub-make], page 52.
.NOTPARALLEL
If .NOTPARALLEL is mentioned as a target, then this invocation of make will
be run serially, even if the ‘-j’ option is given. Any recursively invoked make
command will still run recipes in parallel (unless its makefile also contains this
target). Any prerequisites on this target are ignored.
.ONESHELL
If .ONESHELL is mentioned as a target, then when a target is built all lines of
the recipe will be given to a single invocation of the shell rather than each line
being invoked separately (seeSection5.3[RecipeExecution],page44).
.POSIX
If .POSIX is mentioned as a target, then the makefile will be parsed and run
in POSIX-conforming mode. This does not mean that only POSIX-conforming
makefiles will be accepted: all advanced GNU make features are still available.
Rather, this target causes make to behave as required by POSIX in those areas
where make’s default behavior differs.
In particular, if this target is mentioned then recipes will be invoked as if the
shell had been passed the -e flag: the first failing command in a recipe will
cause the recipe to fail immediately.
Any defined implicit rule suffix also counts as a special target if it appears as a target,
and so does the concatenation of two suffixes, such as ‘.c.o’. These targets are suffix rules,
an obsolete way of defining implicit rules (but a way still widely used). In principle, any
target name could be special in this way if you break it in two and add both pieces to the
suffix list. In practice, suffixes normally begin with ‘.’, so these special target names also
begin with ‘.’. SeeSection10.7[Old-FashionedSuffixRules],page125.
4.9 Multiple Targets in a Rule
Arule with multiple targets is equivalent to writing many rules, each with one target, and
all identical aside from that. The same recipe applies to all the targets, but its effect may
vary because you can substitute the actual target name into the recipe using ‘$@’. The rule
contributes the same prerequisites to all the targets also.
This is useful in two cases.
 You want just prerequisites, no recipe. For example:
kbd.o command.o files.o: command.h
gives an additional prerequisite to each of the three object files mentioned.
 Similar recipes work for all the targets. The recipes do not need to be absolutely
identical, since the automatic variable ‘$@’ can be used to substitute the particular
target to be remade into the commands (see Section 10.5.3 [Automatic Variables],
page 120). Forexample:
control SDK platform:VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
VB.NET PDF - Convert PDF to MS Office Word in VB.NET. VB.NET Tutorial for How to Convert PDF to Word (.docx) Document in VB.NET. Best
www.rasteredge.com
control SDK platform:VB.NET PDF Convert to Tiff SDK: Convert PDF to tiff images in vb.
VB.NET PDF - Convert PDF to TIFF Using VB in VB.NET. Free VB.NET Guide to Render and Convert PDF Document to TIFF in Visual Basic Class.
www.rasteredge.com
Chapter 4: Writing Rules
35
bigoutput littleoutput : text.g
generate text.g -$(subst output,,$@) > $@
is equivalent to
bigoutput : text.g
generate text.g -big > bigoutput
littleoutput : text.g
generate text.g -little > littleoutput
Here we assume the hypothetical program generate makes two types of output, one if
given ‘-big’ and one if given ‘-little’. SeeSection8.2[FunctionsforStringSubsti-
tution and Analysis], page 84,foranexplanationofthesubstfunction.
Suppose you would like to vary the prerequisites according to the target, much as the
variable ‘$@’ allows you to vary the recipe. You cannot do this with multiple targets in an
ordinary rule, but you can do it with a static pattern rule. SeeSection4.11[StaticPattern
Rules], page 36.
4.10 Multiple Rules for One Target
One file can be the target of several rules. All the prerequisites mentioned in all the rules
are merged into one list of prerequisites for the target. If the target is older than any
prerequisite from any rule, the recipe is executed.
There can only be one recipe to be executed for a file. If more than one rule gives a
recipe for the same file, make uses the last one given and prints an error message. (As a
special case, if the file’s name begins with a dot, no error message is printed. This odd
behavior is only for compatibility with other implementations of make.. . you should avoid
using it). Occasionally it is useful to have the same target invoke multiple recipes which are
defined in different parts of your makefile; you can use double-colon rules (seeSection4.12
[Double-Colon], page 38)forthis.
Anextra rule withjust prerequisites can be usedto give a few extra prerequisites to many
files at once. For example, makefiles often have a variable, such as objects, containing a
list of all the compiler output files in the system being made. An easy way to say that all
of them must be recompiled if config.h changes is to write the following:
objects = foo.o bar.o
foo.o : defs.h
bar.o : defs.h test.h
$(objects) : config.h
This could be inserted or taken out without changing the rules that really specify how to
make the object files, making it a convenient form to use if you wish to add the additional
prerequisite intermittently.
Another wrinkle is that the additional prerequisites could be specified with a variable
that you set with a command line argument to make (seeSection9.5[OverridingVariables],
page 103). Forexample,
extradeps=
$(objects) : $(extradeps)
means that the command ‘make extradeps=foo.h’ will consider foo.h as a prerequisite of
each object file, but plain ‘make’ will not.
control SDK platform:C# PDF Convert to SVG SDK: Convert PDF to SVG files in C#.net, ASP
PDFDocument pdf = new PDFDocument(@"C:\input.pdf"); pdf.ConvertToVectorImages( ContextType.SVG, @"C:\demoOutput Description: Convert to html/svg files and
www.rasteredge.com
control SDK platform:C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
C#.NET PDF SDK - Convert PDF to TIFF in C#.NET. Online C# Tutorial for How to Convert PDF File to Tiff Image File with .NET XDoc.PDF Control in C#.NET Class.
www.rasteredge.com
36
GNU make
If none of the explicit rules for a target has a recipe, then make searches for an applicable
implicit rule to find one seeChapter10[UsingImplicitRules],page111).
4.11 Static Pattern Rules
Static pattern rules are rules which specify multiple targets and construct the prerequisite
names for each target based on the target name. They are more general than ordinary rules
with multiple targets because the targets do not have to have identical prerequisites. Their
prerequisites must be analogous, but not necessarily identical.
4.11.1 Syntax of Static Pattern Rules
Here is the syntax of a static pattern rule:
targets ...: target-pattern: prereq-patterns ...
recipe
...
The targets list specifies the targets that the rule applies to. The targets can contain
wildcard characters, just like the targets of ordinary rules (seeSection4.3[UsingWildcard
Characters in File Names], page 23).
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 (‘\’). Back-
slashes 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:
Chapter 4: Writing Rules
37
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 Section10.5.3[Automatic
Variables], page 120.
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 non-matching file names (seeSection8.2[Functionsfor
String Substitution and Analysis], page 84):
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,andthe first static
pattern rule causes each of these object files to be updated by compiling the corresponding
Csource 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’.
4.11.2 Static Pattern Rules versus Implicit Rules
Astatic pattern rule has much in common with an implicit rule defined as a pattern rule
(seeSection10.5[DefiningandRedefiningPatternRules],page118). Both have a pattern
for the target and patterns for constructing the names of prerequisites. The difference is in
how make decides when the rule applies.
An implicit rule can apply to any target that matches its pattern, but it does apply
only when the target has no recipe otherwise specified, and only when the prerequisites can
be found. If more than one implicit rule appears applicable, only one applies; the choice
depends on the order of rules.
By contrast, a static pattern rule applies to the precise list of targets that you specify
in the rule. It cannot apply to any other target and it invariably does apply to each of the
targets specified. If two conflicting rules apply, and both have recipes, that’s an error.
The static pattern rule can be better than an implicit rule for these reasons:
 You may wish to override the usual implicit rule for a few files whose names cannot be
categorized syntactically but can be given in an explicit list.
38
GNU make
 If you cannot be sure of the precise contents of the directories you are using, you may
not be sure which other irrelevant files might lead make to use the wrong implicit rule.
The choice might depend on the order in which the implicit rule search is done. With
static pattern rules, there is no uncertainty: each rule applies to precisely the targets
specified.
4.12 Double-Colon Rules
Double-colon rules are explicit rules written with ‘::’ instead of ‘:’ after the target names.
They are handled differently from ordinary rules when the same target appears in more
than one rule. Pattern rules with double-colons have an entirely different meaning (see
Section 10.5.5 [Match-Anything Rules], page 123).
When a target appears inmultiple rules, allthe rules must be the same type: all ordinary,
or all double-colon. If they are double-colon, each of them is independent of the others.
Each double-colon rule’s recipe is executed if the target is older than any prerequisites of
that rule. If there are no prerequisites for that rule, its recipe is always executed (even if
the target already exists). This can result in executing none, any, or all of the double-colon
rules.
Double-colonrules withthe same target are in fact completely separate from one another.
Each double-colon rule is processed individually, just as rules with different targets are
processed.
The double-colon rules for a target are executed in the order they appear in the makefile.
However, the cases where double-colon rules really make sense are those where the order of
executing the recipes would not matter.
Double-colon rules are somewhat obscure and not often very useful; they provide a
mechanism for cases in which the method used to update a target differs depending on
which prerequisite files caused the update, and such cases are rare.
Each double-colon rule should specify a recipe; if it does not, an implicit rule will be
used if one applies. SeeChapter10[UsingImplicitRules],page111.
4.13 Generating Prerequisites Automatically
In the makefile for a program, many of the rules you need to write often say only that
some object file depends on some header file. For example, if main.c uses defs.h via an
#include, you would write:
main.o: defs.h
You need this rule so that make knows that it must remake main.o whenever defs.h
changes. You can see that for a large program you would have to write dozens of such rules
in your makefile. And, you must always be very careful to update the makefile every time
you add or remove an #include.
To avoid this hassle, most modern C compilers can write these rules for you, by looking
at the #include lines in the source files. Usually this is done with the ‘-M’ option to the
compiler. For example, the command:
cc -M main.c
generates the output:
Chapter 4: Writing Rules
39
main.o : main.c defs.h
Thus you no longer have to write all those rules yourself. The compiler will do it for you.
Note that such a rule constitutes mentioning main.o in a makefile, so it can never be
considered an intermediate file by implicit rule search. This means that make won’t ever
remove the file after using it; seeSection10.4[ChainsofImplicitRules],page117.
With old make programs, it was traditional practice to use this compiler feature to
generate prerequisites on demand with a command like ‘make depend’. That command
would create a file depend containing all the automatically-generated prerequisites; then
the makefile could use include to read them in (seeSection3.3[Include],page13).
In GNU make, the feature of remaking makefiles makes this practice obsolete—you need
never tell make explicitly to regenerate the prerequisites, because it always regenerates any
makefile that is out of date. SeeSection3.5[RemakingMakefiles],page14.
The practice we recommend for automatic prerequisite generation is to have one makefile
corresponding to each source file. For each source file name.c there is a makefile name.d
which lists what files the object file name.o depends on. That way only the source files that
have changed need to be rescanned to produce the new prerequisites.
Here is the pattern rule to generate a file of prerequisites (i.e., a makefile) called name.d
from a C source file called name.c:
%.d: %.c
@set -e; rm -f $@; \
$(CC) -M $(CPPFLAGS) $< > $@.$$$$; \
sed ’s,\($*\)\.o[ :]*,\1.o $@ : ,g’ < $@.$$$$ > $@; \
rm -f $@.$$$$
SeeSection10.5[PatternRules],page118, for information on defining pattern rules. The
‘-e’ flag to the shell causes it to exit immediately if the $(CC) command (or any other
command) fails (exits with a nonzero status).
With the GNU C compiler, you may wish to use the ‘-MM’ flag instead of ‘-M’. This omits
prerequisites on system header files. SeeSection“OptionsControllingthePreprocessor”in
Using GNU CC,fordetails.
The purpose of the sed command is to translate (for example):
main.o : main.c defs.h
into:
main.o main.d : main.c defs.h
This makes each ‘.d’ file depend on all the source and header files that the corresponding
‘.o’ file depends on. make then knows it must regenerate the prerequisites whenever any of
the source or header files changes.
Once you’ve defined the rule to remake the ‘.d’ files, you then use the include directive
to read them all in. SeeSection3.3[Include],page13. For example:
sources = foo.c bar.c
include $(sources:.c=.d)
(This example uses a substitutionvariable reference to translate the list ofsourcefiles ‘foo.c
bar.c’ into a list of prerequisite makefiles, ‘foo.d bar.d’. SeeSection6.3.1[Substitution
Refs], page 62, for r full l information on substitution references.) ) Since e the e ‘.d’ ’ files are
40
GNU make
makefiles like any others, make will remake them as necessary with no further work from
you. SeeSection3.5[RemakingMakefiles],page14.
Note that the ‘.d’ files containtarget definitions; youshouldbe sure to place the include
directive after the first, default goal in your makefiles or run the risk of having a random
object file become the default goal. SeeSection2.3[HowMakeWorks],page5.
Documents you may be interested
Documents you may be interested