convert byte array to pdf mvc : Convert pdf into html online control software platform web page html azure web browser make5-part1944

Chapter 5: Writing Recipes in Rules
5 Writing Recipes in Rules
The recipe of a rule consists of one or more shell command lines to be executed, one at a
time, in the order they appear. Typically, the result of executing these commands is that
the target of the rule is brought up to date.
Users use many different shell programs, but recipes in makefiles are always interpreted
by /bin/sh unless the makefile specifies otherwise. See Section 5.3 [Recipe Execution],
page 44.
5.1 Recipe Syntax
Makefiles have the unusual property that there are really two distinct syntaxes in one
file. Most of the makefile uses make syntax (see Chapter3[WritingMakefiles],page 11).
However, recipes are meant to be interpreted by the shell and so they are written using
shell syntax. The make program does not try to understand shell syntax: it performs only
avery few specific translations on the content of the recipe before handing it to the shell.
Each line in the recipe must start with a tab (or the first character in the value of the
.RECIPEPREFIX variable; seeSection6.14[SpecialVariables],page73), except that the first
recipe line may be attached to the target-and-prerequisites line with a semicolon in between.
Any line in the makefile that begins with a tab and appears in a “rule context” (that is,
after a rule has been started until another rule or variable definition) will be considered
part of a recipe for that rule. Blank lines and lines of just comments may appear among
the recipe lines; they are ignored.
Some consequences of these rules include:
 A blank line that begins with a tab is not blank: it’s an empty recipe (seeSection5.9
[Empty Recipes], page 57).
 A comment in a recipe is not a make comment; it will be passed to the shell as-is.
Whether the shell treats it as a comment or not depends on your shell.
 A variable definitionin a “rule context” which is indentedby a tab as the first character
on the line, will be considered part of a recipe,not a make variable definition, andpassed
to the shell.
 A conditional expression (ifdef, ifeq, etc. seeSection7.2[SyntaxofConditionals],
page 78)ina“rulecontext”whichisindentedby atabas thefirstcharacteronthe
line, will be considered part of a recipe and be passed to the shell.
5.1.1 Splitting Recipe Lines
One of the few ways in which make does interpret recipes is checking for a backslash just
before the newline. As in normal makefile syntax, a single logical recipe line can be split
into multiple physical lines in the makefile by placing a backslash before each newline. A
sequence of lines like this is considered a single recipe line, and one instance of the shell will
be invoked to run it.
However, in contrast to how they are treated in other places in a makefile (see
Section 3.1.1 [Splitting Long Lines], page 12), backslash/newline pairs s are e not t removed
from the recipe. Both the backslash and the newline characters are preserved and passed
to the shell. How the backslash/newline is interpreted depends on your shell. If the first
Convert pdf into html online - control software platform:C# PDF Convert to HTML SDK: Convert PDF to html files in, ASP.NET MVC, WinForms, WPF application
How to Convert PDF to HTML Webpage with C# PDF Conversion SDK
Convert pdf into html online - control software platform:VB.NET PDF Convert to HTML SDK: Convert PDF to html files in, ASP.NET MVC, WinForms, WPF application
PDF to HTML Webpage Converter SDK for VB.NET PDF to HTML Conversion
GNU make
character of the next line after the backslash/newline is the recipe prefix character (a tab
by default; see Section6.14[SpecialVariables],page 73), then that character (and only
that character) is removed. Whitespace is never added to the recipe.
For example, the recipe for the all target in this makefile:
all :
@echo no\
@echo no\
@echo one \
@echo one\
consists of four separate shell commands where the output is:
one space
one space
As a more complex example, this makefile:
all : ; @echo ’hello \
world’ ; echo "hello \
will invoke one shell with a command of:
echo ’hello \
world’ ; echo "hello \
which, according to shell quoting rules, will yield the following output:
hello \
Notice how the backslash/newline pair was removed inside the string quoted with double
quotes ("..."), but not from the string quoted with single quotes (’...’). This is the way
the default shell (/bin/sh) handles backslash/newline pairs. If you specify a different shell
in your makefiles it may treat them differently.
Sometimes you want to split a long line inside of single quotes, but you don’t want the
backslash/newline to appear in the quoted content. This is often the case when passing
scripts to languages such as Perl, where extraneous backslashes inside the script can change
its meaning or even be a syntax error. One simple way of handling this is to place the
quoted string, or even the entire command, into a make variable then use the variable in
the recipe. In this situation the newline quoting rules for makefiles will be used, and the
backslash/newline will be removed. If we rewrite our example above using this method:
HELLO = ’hello \
all : ; @echo $(HELLO)
control software platform:Online Convert PDF to HTML5 files. Best free online PDF html
Download Free Trial. Convert a PDF file to HTML. Just upload your file by clicking on the blue button or drag-and-drop your pdf file into the drop area.
control software platform:C# PDF insert text Library: insert text into PDF content in
Able to add a single text character and text string to PDF files using online source codes in C#.NET class value, The char wil be added into PDF page, 0
Chapter 5: Writing Recipes in Rules
we will get output like this:
hello world
If you like, you can also use target-specific variables (see Section6.11 [Target-specific
Variable Values], page 71)toobtainatightercorrespondencebetweenthevariableandthe
recipe that uses it.
5.1.2 Using Variables in Recipes
The other way in which make processes recipes is by expanding any variable references in
them (seeSection6.1[Reference],page59). This occurs after make has finished reading
all the makefiles and the target is determined to be out of date; so, the recipes for targets
which are not rebuilt are never expanded.
Variable and function references in recipes have identical syntax and semantics to ref-
erences elsewhere in the makefile. They also have the same quoting rules: if you want a
dollar sign to appear in your recipe, you must double it (‘$$’). For shells like the default
shell, that use dollar signs to introduce variables, it’s important to keep clear in your mind
whether the variable you want to reference is a make variable (use a single dollar sign) or a
shell variable (use two dollar signs). For example:
LIST = one two three
for i in $(LIST); do \
echo $$i; \
results in the following command being passed to the shell:
for i in one two three; do \
echo $i; \
which generates the expected result:
5.2 Recipe Echoing
Normally make prints each line of the recipe before it is executed. We call this echoing
because it gives the appearance that you are typing the lines yourself.
When a line starts with ‘@’, the echoing of that line is suppressed. The ‘@’ is discarded
before the line is passed to the shell. Typically you would use this for a command whose
only effect is to print something, such as an echo command to indicate progress through
the makefile:
@echo About to make distribution files
When make is given the flag ‘-n’ or ‘--just-print’ it only echoes most recipes, without
executing them. See Section9.7[SummaryofOptions],page 104. In this case even the
recipe lines starting with ‘@’ are printed. This flag is useful for finding out which recipes
make thinks are necessary without actually doing them.
control software platform:C# PDF Convert to Tiff SDK: Convert PDF to tiff images in
with specified zoom value and save it into stream The magnification of the original PDF page size Description: Convert to DOCX/TIFF with specified resolution and
control software platform:VB.NET PDF File Split Library: Split, seperate PDF into multiple
Split PDF file into two or multiple files in ASP.NET webpage online. Support to break a large PDF file into smaller files in .NET WinForms.
GNU make
The ‘-s’ or ‘--silent’ flag to make prevents all echoing, as if all recipes started with
‘@’. A rule in the makefile for the special target .SILENT without prerequisites has the same
effect (see Section4.8 [SpecialBuilt-in Target Names], page 32). .SILENT is essentially
obsolete since ‘@’ is more flexible.
5.3 Recipe Execution
When it is time to execute recipes to update a target, they are executed by invoking a new
sub-shell for each line of the recipe, unless the .ONESHELL special target is in effect (see
Section 5.3.1 [Using One Shell], page 44)(Inpractice,makemaytakeshortcutsthatdonot
affect the results.)
Please note: this implies that setting shell variables and invoking shell commands such
as cd that set a context localto each process will not affect the following lines in the recipe.
If you want to use cd to affect the next statement, put both statements in a single recipe
line. Then make will invoke one shell to run the entire line, and the shell will execute the
statements in sequence. For example:
foo : bar/lose
cd $(@D) && gobble $(@F) > ../$@
Here we use the shell AND operator (&&) so that if the cd command fails, the script will fail
without trying to invoke the gobble command in the wrong directory, which could cause
problems (in this case it would certainly cause ../foo to be truncated, at least).
5.3.1 Using One Shell
Sometimes you would prefer that all the lines in the recipe be passed to a single invocation
of the shell. There are generally two situations where this is useful: first, it can improve
performance in makefiles where recipes consist of many command lines, by avoiding extra
processes. Second, you might want newlines to be included in your recipe command (for
example perhaps you are using a very different interpreter as your SHELL). If the .ONESHELL
special target appears anywhere in the makefile then all recipe lines for each target will be
provided to a single invocation of the shell. Newlines between recipe lines will be preserved.
For example:
foo : bar/lose
cd $(@D)
gobble $(@F) > ../$@
would now work as expected even though the commands are on different recipe lines.
If .ONESHELL is provided, then only the first line of the recipe will be checked for the
special prefix characters (‘@’, ‘-’, and ‘+’). Subsequent lines will include the special char-
acters in the recipe line when the SHELL is invoked. If you want your recipe to start with
one of these special characters you’ll need to arrange for them to not be the first characters
on the first line, perhaps by adding a comment or similar. For example, this would be a
syntax error in Perl because the first ‘@’ is removed by make:
On MS-DOS, the value of current working directory is global, so changing it will affect the following
recipe lines on those systems.
control software platform:VB.NET PDF insert image library: insert images into PDF in
Insert images into PDF form field in VB.NET. image to PDF in preview without adobe PDF control installed. Access to freeware download and online VB.NET class
control software platform:C# PDF File Split Library: Split, seperate PDF into multiple files
SharePoint. C#.NET control for splitting PDF file into two or multiple files online. Support to break a large PDF file into smaller files.
Chapter 5: Writing Recipes in Rules
SHELL = /usr/bin/perl
show :
@f = qw(a b c);
print "@f\n";
However, either of these alternatives would work properly:
SHELL = /usr/bin/perl
show :
# Make sure "@" is not the first character on the first line
@f = qw(a b c);
print "@f\n";
SHELL = /usr/bin/perl
show :
my @f = qw(a b c);
print "@f\n";
As a special feature, if SHELL is determined to be a POSIX-style shell, the special prefix
characters in “internal” recipe lines will removed before the recipe is processed. This feature
is intended to allow existing makefiles to add the .ONESHELL special target and still run
properly without extensive modifications. Since the special prefix characters are not legal
at the beginning of a line in a POSIX shell script this is not a loss in functionality. For
example, this works as expected:
foo : bar/lose
@cd $(@D)
@gobble $(@F) > ../$@
Evenwiththis special feature, however, makefiles with .ONESHELL will behave differently
in ways that could be noticeable. For example, normally if any line in the recipe fails, that
causes the rule to fail and no more recipe lines are processed. Under .ONESHELL a failure
of any but the final recipe line will not be noticed by make. You can modify .SHELLFLAGS
to add the -e option to the shell which will cause any failure anywhere in the command
line to cause the shell to fail, but this could itself cause your recipe to behave differently.
Ultimately you may need to harden your recipe lines to allow them to work with .ONESHELL.
5.3.2 Choosing the Shell
The program used as the shell is taken from the variable SHELL. If this variable is not set
in your makefile, the program /bin/sh is used as the shell. The argument(s) passed to the
shell are taken from the variable .SHELLFLAGS. The default value of .SHELLFLAGS is -c
normally, or -ec in POSIX-conforming mode.
control software 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# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write
control software platform:VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Ability to create a blank PDF page with related by using following online VB.NET source code. DLLs for Adding Page into PDF Document in VB.NET Class.
GNU make
Unlike most variables, the variable SHELL is never set from the environment. This is
because the SHELL environment variable is used to specify your personal choice of shell
program for interactive use. It would be very bad for personal choices like this to affect the
functioning of makefiles. SeeSection6.10[VariablesfromtheEnvironment],page70.
Furthermore, when you do set SHELL in your makefile that value is not exported in the
environment to recipe lines that make invokes. Instead, the value inherited from the user’s
environment, if any, is exported. You can override this behavior by explicitly exporting
SHELL (seeSection5.7.2[CommunicatingVariablestoaSub-make],page52), forcing it to
be passed in the environment to recipe lines.
However, on MS-DOS and MS-Windows the value of SHELL in the environment is used,
since on those systems most users do not set this variable, and therefore it is most likely
set specifically to be used by make. On MS-DOS, if the setting of SHELL is not suitable for
make, you can set the variable MAKESHELL to the shell that make should use; if set it will be
used as the shell instead of the value of SHELL.
Choosing a Shell in DOS and Windows
Choosing a shellin MS-DOS andMS-Windows is much morecomplex thanonother systems.
On MS-DOS, if SHELL is not set, the value of the variable COMSPEC (which is always set)
is used instead.
The processing of lines that set the variable SHELL in Makefiles is different on MS-DOS.
The stock shell,, is ridiculously limited in its functionality and many users of
make tend to install a replacement shell. Therefore, on MS-DOS, make examines the value
of SHELL, and changes its behavior based on whether it points to a Unix-style or DOS-style
shell. This allows reasonable functionality even if SHELL points to
If SHELL points to a Unix-style shell, make on MS-DOS additionally checks whether that
shell can indeed be found; if not, it ignores the line that sets SHELL. In MS-DOS, GNU
make searches for the shell in the following places:
1. In the precise place pointed to by the value of SHELL. For example, if the makefile
specifies ‘SHELL = /bin/sh’, make will look in the directory /bin on the current drive.
2. In the current directory.
3. In each of the directories in the PATH variable, in order.
In every directory it examines, make will first look for the specific file (sh in the example
above). If this is not found, it will also look in that directory for that file with one of the
known extensions which identify executable files. For example .exe, .com, .bat, .btm, .sh,
and some others.
If any of these attempts is successful, the value of SHELL will be set to the full pathname
of the shell as found. However, if none of these is found, the value of SHELL will not be
changed, and thus the line that sets it will be effectively ignored. This is so make will only
support features specific to a Unix-style shell if such a shell is actually installed on the
system where make runs.
Note that this extended search for the shell is limited to the cases where SHELL is set
from the Makefile; if it is set in the environment or command line, you are expected to set
it to the full pathname of the shell, exactly as things are on Unix.
Chapter 5: Writing Recipes in Rules
The effect of the above DOS-specific processing is that a Makefile that contains ‘SHELL
=/bin/sh’ (as many Unix makefiles do), will work on MS-DOS unaltered if you have e.g.
sh.exe installed in some directory along your PATH.
5.4 Parallel Execution
GNU make knows how to execute several recipes at once. Normally, make will execute
only one recipe at a time, waiting for it to finish before executing the next. However, the
‘-j’ or ‘--jobs’ option tells make to execute many recipes simultaneously. You can inhibit
parallelism in a particular makefile with the .NOTPARALLEL pseudo-target (seeSection4.8
[Special Targets], page 32).
On MS-DOS, the ‘-j’ option has no effect, since that system doesn’t support multi-
If the ‘-j’ option is followed by an integer, this is the number of recipes to execute at
once; this is called the number of job slots. If there is nothing looking like an integer after
the ‘-j’ option, there is no limit on the number of job slots. The default number of job
slots is one, which means serial execution (one thing at a time).
Handling recursive make invocations raises issues for parallel execution. For more infor-
mation on this, seeSection5.7.3[CommunicatingOptionstoaSub-make],page54.
If a recipe fails (is killed by a signal or exits with a nonzero status), and errors are
not ignored for that recipe (seeSection 5.5 [Errors s inRecipes], , page49), the remaining
recipe lines to remake the same target will not be run. If a recipe fails and the ‘-k’ or
‘--keep-going’ option was not given (see Section 9.7[Summary y ofOptions],page104),
make aborts execution. If make terminates for any reason (including a signal) with child
processes running, it waits for them to finish before actually exiting.
When the system is heavily loaded, you will probably want to run fewer jobs than when
it is lightly loaded. You can use the ‘-l’ option to tell make to limit the number of jobs to
run at once, based on the load average. The ‘-l’ or ‘--max-load’ option is followed by a
floating-point number. For example,
-l 2.5
will not let make start more than one job if the load average is above 2.5. The ‘-l’ option
with no following number removes the load limit, if one was given with a previous ‘-l’
More precisely, when make goes to start up a job, and it already has at least one job
running, it checks the current load average; if it is not lower than the limit given with ‘-l’,
make waits until the load average goes below that limit, or until all the other jobs finish.
By default, there is no load limit.
5.4.1 Output During Parallel Execution
When running several recipes in parallel the output from each recipe appears as soon as
it is generated, with the result that messages from different recipes may be interspersed,
sometimes even appearing on the same line. This can make reading the output very difficult.
To avoid this you can use the ‘--output-sync’ (‘-O’) option. This option instructs make
to save the output from the commands it invokes and print it all once the commands are
GNU make
completed. Additionally,if there are multiple recursive make invocations running in parallel,
they will communicate so that only one of them is generating output at a time.
If working directory printing is enabled (see Section5.7.4 [The ‘--print-directory’
Option], page 55),theenter/leavemessagesareprintedaroundeachoutputgrouping. If
youprefer not to see these messages add the ‘--no-print-directory’ option to MAKEFLAGS.
There are four levels of granularity when synchronizing output, specified by giving an
argument to the option (e.g., ‘-Oline’ or ‘--output-sync=recurse’).
This is the default: all output is sent directly as it is generated and no synchro-
nization is performed.
Output from each individual line of the recipe is grouped and printed as soon
as that line is complete. If a recipe consists of multiple lines, they may be
interspersed with lines from other recipes.
Output from the entire recipe for each target is grouped and printed once the
target is complete. This is the default if the --output-sync or -O option is
given with no argument.
Output from each recursive invocation of make is grouped and printed once the
recursive invocation is complete.
Regardless of the mode chosen, the totalbuildtime will be the same. The only difference
is in how the output appears.
The ‘target’and ‘recurse’ modes both collect the output of the entire recipe of a target
and display it uninterrupted when the recipe completes. The difference between them is in
how recipes that contain recursive invocations of make are treated(seeSection5.7[Recursive
Use of make], page 50). For r all l recipes which have no recursive lines, the ‘target’ and
‘recurse’ modes behave identically.
If the ‘recurse’ mode is chosen, recipes that contain recursive make invocations are
treated the same as other targets: the output from the recipe, including the output from
the recursive make, is saved and printed after the entire recipe is complete. This ensures
output from all the targets built by a given recursive make instance are grouped together,
which may make the output easier to understand. However it also leads to long periods of
time during the build where no output is seen, followed by large bursts of output. If you
are not watching the build as it proceeds, but instead viewing a log of the build after the
fact, this may be the best option for you.
If you are watching the output, the long gaps of quiet during the build can be frustrat-
ing. The ‘target’ output synchronization mode detects when make is going to be invoked
recursively, using the standard methods, and it will not synchronize the output of those
lines. The recursive make will perform the synchronization for its targets and the output
from each will be displayed immediately when it completes. Be aware that output from
recursive lines of the recipe are not synchronized (for example if the recursive line prints a
message before running make, that message will not be synchronized).
The ‘line’ mode can be useful for front-ends that are watching the output of make to
track when recipes are started and completed.
Some programs invokedby make may behave differently if they determine they’re writing
output to a terminal versus a file (often described as “interactive” vs. “non-interactive”
Chapter 5: Writing Recipes in Rules
modes). For example, many programs that can display colorized output will not do so
if they determine they are not writing to a terminal. If your makefile invokes a program
like this then using the output synchronization options will cause the program to believe
it’s running in “non-interactive” mode even though the output will ultimately go to the
5.4.2 Input During Parallel Execution
Two processes cannot both take input from the same device at the same time. To make
sure that only one recipe tries to take input from the terminal at once, make will invalidate
the standard input streams of all but one running recipe. If another recipe attempts to read
from standard input it will usually incur a fatal error (a ‘Broken pipe’ signal).
It is unpredictable which recipe will have a valid standard input stream (which will come
from the terminal, or wherever you redirect the standard input of make). The first recipe
run will always get it first, and the first recipe started after that one finishes will get it next,
and so on.
We will change how this aspect of make works if we find a better alternative. In the
mean time, you should not rely on any recipe using standard input at all if you are using
the parallel execution feature; but if you are not using this feature, then standard input
works normally in all recipes.
5.5 Errors in Recipes
After each shell invocation returns, make looks at its exit status. If the shell completed
successfully (the exit status is zero), the next line in the recipe is executed in a new shell;
after the last line is finished, the rule is finished.
If there is an error (the exit status is nonzero), make gives up on the current rule, and
perhaps on all rules.
Sometimes the failure of a certain recipe line does not indicate a problem. For example,
you may use the mkdir command to ensure that a directory exists. If the directory already
exists, mkdir will report an error, but you probably want make to continue regardless.
To ignore errors in a recipe line, write a ‘-’ at the beginning of the line’s text (after the
initial tab). The ‘-’ is discarded before the line is passed to the shell for execution.
For example,
-rm -f *.o
This causes make to continue even if rm is unable to remove a file.
When you run make with the ‘-i’ or ‘--ignore-errors’ flag, errors are ignored in all
recipes of all rules. A rule in the makefile for the special target .IGNORE has the same effect,
if there are no prerequisites. These ways of ignoring errors are obsolete because ‘-’ is more
When errors are to be ignored, because of either a ‘-’ or the ‘-i’ flag, make treats an
error return just like success, except that it prints out a message that tells you the status
code the shell exited with, and says that the error has been ignored.
When an error happens that make has not been told to ignore, it implies that the
current target cannot be correctly remade, and neither can any other that depends on it
GNU make
either directly or indirectly. No further recipes will be executed for these targets, since their
preconditions have not been achieved.
Normally make gives up immediately in this circumstance, returning a nonzero status.
However, if the ‘-k’ or ‘--keep-going’ flag is specified, make continues to consider the
other prerequisites of the pending targets, remaking them if necessary, before it gives up
and returns nonzero status. For example, after an error in compiling one object file, ‘make
-k’ willcontinue compiling other object files eventhough it already knows that linking them
will be impossible. SeeSection9.7[SummaryofOptions],page104.
The usual behavior assumes that your purpose is to get the specified targets up to date;
once make learns that this is impossible, it might as well report the failure immediately.
The ‘-k’ option says that the real purpose is to test as many of the changes made in the
program as possible, perhaps to find several independent problems so that you can correct
them all before the next attempt to compile. This is why Emacs’ compile command passes
the ‘-k’ flag by default.
Usually when a recipe line fails, if it has changed the target file at all, the file is corrupted
and cannot be used—or at least it is not completely updated. Yet the file’s time stamp says
that it is now up to date, so the next time make runs, it will not try to update that file. The
situation is just the same as when the shell is killed by a signal; seeSection5.6[Interrupts],
page 50.Sogenerallytherightthingtodoistodeletethetargetfileiftherecipefailsafter
beginning to change the file. make will do this if .DELETE_ON_ERROR appears as a target.
This is almost always what you want make to do, but it is not historical practice; so for
compatibility, you must explicitly request it.
5.6 Interrupting or Killing make
If make gets a fatal signal while a shell is executing, it may delete the target file that the
recipe was supposed to update. This is done if the target file’s last-modification time has
changed since make first checked it.
The purpose of deleting the target is to make sure that it is remade from scratch when
make is next run. Why is this? Suppose you type Ctrl-c while a compiler is running, and
it has begun to write an object file foo.o. The Ctrl-c kills the compiler, resulting in an
incomplete file whose last-modification time is newer than the source file foo.c. But make
also receives the Ctrl-c signal and deletes this incomplete file. If make did not do this, the
next invocation of make would think that foo.o did not require updating—resulting in a
strange error message from the linker when it tries to link an object file half of which is
You can prevent the deletion of a target file in this way by making the special target
.PRECIOUS depend on it. Before remaking a target, make checks to see whether it appears
on the prerequisites of .PRECIOUS, and thereby decides whether the target should be deleted
if a signal happens. Some reasons why you might do this are that the target is updated
in some atomic fashion, or exists only to record a modification-time (its contents do not
matter), or must exist at all times to prevent other sorts of trouble.
5.7 Recursive Use of make
Recursive use of make means using make as a command in a makefile. This technique
is useful when you want separate makefiles for various subsystems that compose a larger
Documents you may be interested
Documents you may be interested