convert byte array to pdf mvc : Convert pdf to url software application dll winforms windows azure web forms make2-part1937

Chapter 3: Writing Makefiles
3 Writing Makefiles
The information that tells make how to recompile a system comes from reading a data base
called the makefile.
3.1 What Makefiles Contain
Makefiles contain five kinds of things: explicit rules, implicit rules, variable definitions,
directives, and comments. Rules, variables, and directives are described at length in later
 Anexplicit rule says whenandhow to remake one or more files, called the rule’s targets.
It lists the other files that the targets depend on, called the prerequisites of the target,
and may also give a recipe to use to create or update the targets. See Chapter 4
[Writing Rules], page 21.
 An implicit rule says when and how to remake a class of files based on their names.
It describes how a target may depend on a file with a name similar to the target and
gives a recipe to create or update such a target. SeeChapter10[UsingImplicitRules],
page 111.
 A variable definition is a line that specifies a text string value for a variable that
can be substituted into the text later. The simple makefile example shows a variable
definition for objects as a list of all object files (see Section 2.4 [Variables Make
Makefiles Simpler], page 6).
 A directive is aninstruction for make to do something special while readingthe makefile.
These include:
 Reading another makefile (seeSection3.3[IncludingOtherMakefiles],page13).
 Deciding (based on the values of variables) whether to use or ignore a part of the
makefile (seeChapter7[ConditionalPartsofMakefiles],page77).
 Defining a variable froma verbatimstring containing multiple lines (seeSection6.8
[Defining Multi-Line Variables], page 69).
 ‘#’ in a line of a makefile starts a comment. It and the rest of the line are ignored,
except that a trailing backslash not escaped by another backslash will continue the
comment across multiple lines. A line containing just a comment (with perhaps spaces
before it) is effectively blank, and is ignored. If you want a literal #, escape it with a
backslash (e.g., \#). Comments may appear on any line in the makefile, although they
are treated specially in certain situations.
You cannot use comments within variable references or function calls: any instance
of # will be treated literally (rather than as the start of a comment) inside a variable
reference or function call.
Comments within a recipe are passed to the shell, just as with any other recipe text.
The shell decides how to interpret it: whether or not this is a comment is up to the
Within a define directive, comments are not ignored during the definition of the
variable, but rather kept intact in the value of the variable. When the variable is
expanded they will either be treated as make comments or as recipe text, depending
on the context in which the variable is evaluated.
Convert pdf to url - software application dll: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 to url - software application dll: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
3.1.1 Splitting Long Lines
Makefiles use a “line-based” syntax in which the newline character is special and marks the
end of a statement. GNU make has no limit on the length of a statement line, up to the
amount of memory in your computer.
However, it is difficult to read lines which are too long to display without wrapping or
scrolling. So, you can format your makefiles for readability by adding newlines into the
middle of a statement: you do this by escaping the internal newlines with a backslash (\)
character. Where we need to make a distinction we will refer to “physical lines” as a single
line ending with a newline (regardless of whether it is escaped) and a “logical line” being a
complete statement including all escaped newlines up to the first non-escaped newline.
The way in which backslash/newline combinations are handled depends on whether the
statement is a recipe line or a non-recipe line. Handling of backslash/newline in a recipe
line is discussed later (seeSection5.1.1[SplittingRecipeLines],page41).
Outside of recipe lines, backslash/newlines are converted into a single space character.
Once that is done, all whitespace around the backslash/newline is condensed into a single
space: this includes all whitespace preceding the backslash, all whitespace at the beginning
of the line after the backslash/newline, and any consecutive backslash/newline combina-
If the .POSIX special target is defined then backslash/newline handling is modified
slightly to conform to POSIX.2: first, whitespace preceding a backslash is not removed
and second, consecutive backslash/newlines are not condensed.
3.2 What Name to Give Your Makefile
By default, when make looks for the makefile, it tries the following names, in order:
GNUmakefile, makefile and Makefile.
Normally you should call your makefile either makefile or Makefile. (We recommend
Makefile because it appears prominently near the beginning of a directory listing, right
near other important files such as README.) The first name checked, GNUmakefile, is not
recommended for most makefiles. You should use this name if you have a makefile that is
specific to GNU make, and will not be understood by other versions of make. Other make
programs look for makefile and Makefile, but not GNUmakefile.
If make finds none of these names, it does not use any makefile. Then you must specify
agoal with a command argument, and make will attempt to figure out how to remake it
using only its built-in implicit rules. SeeChapter10[UsingImplicitRules],page111.
If you want to use a nonstandard name for your makefile, you can specify the makefile
name with the ‘-f’ or ‘--file’ option. The arguments ‘-f name’ or ‘--file=name’ tell
make to read the file name as the makefile. If you use more than one ‘-f’ or ‘--file’
option, you can specify several makefiles. All the makefiles are effectively concatenated in
the order specified. The default makefile names GNUmakefile, makefile and Makefile are
not checked automatically if you specify ‘-f’ or ‘--file’.
software application dll:C# PDF url edit Library: insert, remove PDF links in, ASP.
C#.NET PDF SDK - Edit PDF Hyperlink (url) in C#.NET. Enable users to copy and paste PDF link. Help to extract and search url in PDF file.
software application dll:VB.NET PDF url edit library: insert, remove PDF links in
VB.NET PDF - Edit PDF Hyperlink (url) in VB.NET. Make PDF link open in a new window, blank page or tab. Edit PDF url in preview without adobe PDF reader control.
Chapter 3: Writing Makefiles
3.3 Including Other Makefiles
The include directive tells make to suspend reading the current makefile and read one or
more other makefiles before continuing. The directive is a line in the makefile that looks
like this:
include filenames...
filenames can contain shell file name patterns. If filenames is empty, nothing is included
and no error is printed.
Extra spaces are allowed and ignored at the beginning of the line, but the first character
must not be a tab (or the value of .RECIPEPREFIX)—if the line begins with a tab, it will
be considered a recipe line. Whitespace is required between include and the file names,
and between file names; extra whitespace is ignored there and at the end of the directive.
Acomment starting with ‘#’ is allowed at the end of the line. If the file names contain any
variable or function references, they are expanded. SeeChapter6[HowtoUseVariables],
page 59.
For example, if you have three .mk files,,, and, and $(bar) expands to
bish bash, then the following expression
include foo *.mk $(bar)
is equivalent to
include foo bish bash
When make processes an include directive,it suspends readingofthe containing makefile
and reads from each listed file in turn. When that is finished, make resumes reading the
makefile in which the directive appears.
One occasion for using include directives is when several programs, handled by indi-
vidual makefiles in various directories, need to use a common set of variable definitions (see
Section 6.5 [Setting Variables], page 65) or pattern n rules s (see Section 10.5 [Defining and
Redefining Pattern Rules], page 118).
Another such occasion is when you want to generate prerequisites from source files
automatically; the prerequisites can be put in a file that is included by the main makefile.
This practice is generally cleaner than that of somehow appending the prerequisites to the
end of the main makefile as has been traditionally done with other versions of make. See
Section 4.13 [Automatic Prerequisites], page 38.
If the specified name does not start with a slash, and the file is not found in the
current directory, several other directories are searched. First, any directories you have
specified with the ‘-I’ or ‘--include-dir’ option are searched (seeSection9.7[Summary
of Options], page 104). Then n the following directories s (if they exist) are searched, , in
this order:
prefix/include (normally /usr/local/include
) /usr/gnu/include,
/usr/local/include, /usr/include.
If an included makefile cannot be found in any of these directories, a warning message
is generated, but it is not an immediately fatal error; processing of the makefile containing
the include continues. Once it has finished reading makefiles, make will try to remake any
that are out of date or don’t exist. SeeSection3.5[HowMakefilesAreRemade],page14.
GNU Make compiled for MS-DOS and MS-Windows behaves as if prefix has been defined to be the root
of the DJGPP tree hierarchy.
software application dll:C#: How to Open a File from a URL (HTTP, FTP) in HTML5 Viewer
PDF to svg, C#.NET convert PDF to text, C#.NET convert PDF to images VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel C# HTML5 Viewer: Open a File from a URL.
software application dll:C#: How to Add HTML5 Document Viewer Control to Your Web Page
new RECommand("convert")); _tabFile.addCommand new UserCommand("pdf"); _userCmdDemoPdf. addCSS new customStyle({ background: "url('RasterEdge_Resource_Files/images
GNU make
Only after it has tried to find a way to remake a makefile and failed, will make diagnose the
missing makefile as a fatal error.
If you want make to simply ignore a makefile which does not exist or cannot be remade,
with no error message, use the -include directive instead of include, like this:
-include filenames...
This acts like include in every way except that there is no error (not even a warning)
if any of the filenames (or any prerequisites of any of the filenames) do not exist or cannot
be remade.
For compatibility with some other make implementations, sinclude is another name for
3.4 The Variable MAKEFILES
If the environment variable MAKEFILES is defined, make considers its value as a list of
names (separated by whitespace) of additional makefiles to be read before the others. This
works much like the include directive: various directories are searched for those files (see
Section 3.3 [Including Other Makefiles], page 13). In n addition, thedefault t goal l is s never
taken from one of these makefiles (or any makefile included by them) and it is not an error
if the files listed in MAKEFILES are not found.
The main use of MAKEFILES is in communication between recursive invocations of make
(seeSection5.7[RecursiveUseofmake],page50). It usually is not desirable to set the
environment variable before a top-level invocation of make, because it is usually better not
to mess with a makefile from outside. However, if you are running make without a specific
makefile, a makefile in MAKEFILES can do useful things to help the built-in implicit rules
work better, such as defining search paths (seeSection4.4[DirectorySearch],page25).
Some users are tempted to set MAKEFILES in the environment automatically on login,
and program makefiles to expect this to be done. This is a very bad idea, because such
makefiles will fail to work if run by anyone else. It is much better to write explicit include
directives in the makefiles. SeeSection3.3[IncludingOtherMakefiles],page13.
3.5 How Makefiles Are Remade
Sometimes makefiles can be remade from other files, suchas RCSor SCCSfiles. If a makefile
can be remade from other files, you probably want make to get an up-to-date version of the
makefile to read in.
To this end, after reading in all makefiles, make will consider each as a goal target and
attempt to update it. If a makefile has a rule which says how to update it (found either
in that very makefile or in another one) or if an implicit rule applies to it (seeChapter10
[Using Implicit Rules], page 111),itwillbeupdatedifnecessary. Afterallmakefileshave
been checked, if any have actually been changed, make starts with a clean slate and reads
all the makefiles over again. (It will also attempt to update each of them over again, but
normally this will not change them again, since they are already up to date.)
If you know that one or more of your makefiles cannot be remade and you want to keep
make from performing an implicit rule search on them, perhaps for efficiency reasons, you
can use any normal method of preventing implicit rule look-up to do so. For example,
software application dll:VB.NET Image: VB Code to Download and Save Image from Web URL
Apart from image downloading from web URL, RasterEdge .NET Imaging SDK still dedicated to provide powerful & profession imaging controls, PDF document, image
software application dll:C# HTML5 PDF Viewer SDK to view PDF document online in C#.NET
NET extract PDF pages, VB.NET comment annotate PDF, VB.NET delete PDF pages, VB.NET convert PDF to SVG. Able to load PDF document from file formats and url.
Chapter 3: Writing Makefiles
you can write an explicit rule with the makefile as the target, and an empty recipe (see
Section 5.9 [Using Empty Recipes], page 57).
If the makefiles specify a double-colon rule to remake a file with a recipe but no prereq-
uisites, that file will always be remade (seeSection4.12[Double-Colon],page38). In the
case of makefiles, a makefile that has a double-colon rule with a recipe but no prerequisites
will be remade every time make is run, and then again after make starts over and reads
the makefiles in again. This would cause an infinite loop: make would constantly remake
the makefile, and never do anything else. So, to avoid this, make will not attempt to re-
make makefiles which are specified as targets of a double-colon rule with a recipe but no
If you do not specify any makefiles to be read with ‘-f’ or ‘--file’ options, make will try
the default makefile names; seeSection3.2[WhatNametoGiveYourMakefile],page12.
Unlike makefiles explicitly requested with ‘-f’ or ‘--file’ options, make is not certain that
these makefiles should exist. However, if a default makefile does not exist but can be created
by running make rules, you probably want the rules to be run so that the makefile can be
Therefore, if none of the default makefiles exists, make will try to make each of them in
the same order in which they are searched for (seeSection3.2[WhatNametoGiveYour
Makefile], page 12) untilitsucceedsinmakingone,or itrunsoutofnames totry. . Note
that it is not an error if make cannot find or make any makefile; a makefile is not always
When you use the ‘-t’or ‘--touch’option(seeSection9.3[InsteadofExecutingRecipes],
page 101),youwouldnotwanttouseanout-of-datemakefile todecide whichtargets to
touch. So the ‘-t’ option has no effect on updating makefiles; they are really updated even
if ‘-t’ is specified. Likewise, ‘-q’ (or ‘--question’) and ‘-n’ (or ‘--just-print’) do not
prevent updating of makefiles, because an out-of-date makefile would result in the wrong
output for other targets. Thus, ‘make -f mfile -n foo’ will update mfile, read it in, and
then print the recipe to update foo and its prerequisites without running it. The recipe
printed for foo will be the one specified in the updated contents of mfile.
However, on occasion you might actually wish to prevent updating of even the makefiles.
You can do this by specifying the makefiles as goals in the commandline as wellas specifying
them as makefiles. When the makefile name is specified explicitly as a goal, the options ‘-t’
and so on do apply to them.
Thus, ‘make -f mfile -n mfile foo’ would read the makefile mfile, print the recipe
needed to update it without actually running it, and then print the recipe needed to update
foo without running that. The recipe for foo will be the one specified by the existing
contents of mfile.
3.6 Overriding Part of Another Makefile
Sometimes it is useful to have a makefile that is mostly just like another makefile. You
can often use the ‘include’ directive to include one in the other, and add more targets or
variable definitions. However, it is invalid for two makefiles to give different recipes for the
same target. But there is another way.
In the containing makefile (the one that wants to include the other), you can use a
match-anything pattern rule to say that to remake any target that cannot be made from
software application dll:VB.NET PDF Library SDK to view, edit, convert, process PDF file
Able to render and convert PDF document to/from supported document package offers robust APIs for editing PDF document hyperlink (url), which provide
software application dll:C# Image: How to Download Image from URL in C# Project with .NET
convert image to byte, and how to convert an image jpg, or bmp image from a URL to your to provide powerful & profession imaging controls, PDF document, tiff
GNU make
the information in the containing makefile, make should look in another makefile. See
Section 10.5 [Pattern Rules], page 118,formoreinformationonpatternrules.
For example, if you have a makefile called Makefile that says how to make the target
‘foo’ (and other targets), you can write a makefile called GNUmakefile that contains:
frobnicate > foo
%: force
@$(MAKE) -f Makefile $@
force: ;
If you say ‘make foo’, make will find GNUmakefile, read it, and see that to make foo,
it needs to run the recipe ‘frobnicate > foo’. If you say ‘make bar’, make will find no
way to make bar in GNUmakefile, so it will use the recipe from the pattern rule: ‘make
-f Makefile bar’. If Makefile provides a rule for updating bar, make will apply the rule.
And likewise for any other target that GNUmakefile does not say how to make.
The way this works is that the pattern rule has a pattern of just ‘%’, so it matches any
target whatever. The rule specifies a prerequisite force, to guarantee that the recipe will
be run even if the target file already exists. We give the force target an empty recipe to
prevent make from searching for an implicit rule to build it—otherwise it would apply the
same match-anything rule to force itself and create a prerequisite loop!
3.7 How make Reads a Makefile
GNU make does its work in two distinct phases. During the first phase it reads allthe make-
files, included makefiles, etc. and internalizes all the variables and their values, implicit and
explicit rules, and constructs a dependency graph of all the targets and their prerequisites.
During the second phase, make uses these internal structures to determine what targets will
need to be rebuilt and to invoke the rules necessary to do so.
It’s important to understand this two-phase approach because it has a direct impact
on how variable and function expansion happens; this is often a source of some confusion
when writing makefiles. Here we will present a summary of the phases in which expansion
happens for different constructs within the makefile. We say that expansion is immediate if
it happens during the first phase: in this case make will expand any variables or functions
in that section of a construct as the makefile is parsed. We say that expansion is deferred if
expansionis not performed immediately. Expansion of a deferred construct is not performed
until either the construct appears later in an immediate context, or until the second phase.
You may not be familiar withsome of these constructs yet. Youcan reference this section
as you become familiar with them, in later chapters.
Variable Assignment
Variable definitions are parsed as follows:
immediate = deferred
immediate ?= deferred
immediate := immediate
immediate ::= immediate
immediate += deferred or immediate
software application dll:VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
PDF to Text. Convert PDF to JPEG. Convert PDF to Png to PDF. Image: Remove Image from PDF Page. Image Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete
software application dll:C# PDF Library SDK to view, edit, convert, process PDF file for C#
provides C# users abilities to view, annotate, convert and create NET package offers robust APIs for editing PDF document hyperlink (url) and quick
Chapter 3: Writing Makefiles
immediate != immediate
define immediate
define immediate =
define immediate ?=
define immediate :=
define immediate ::=
define immediate +=
deferred or immediate
define immediate !=
For the append operator, ‘+=’, the right-hand side is considered immediate if the variable
was previously set as a simple variable (‘:=’ or ‘::=’), and deferred otherwise.
For the shell assignment operator, ‘!=’, the right-hand side is evaluated immediately and
handed to the shell. The result is stored in the variable named on the left, and that variable
becomes a simple variable (and will thus be re-evaluated on each reference).
Conditional Directives
Conditional directives are parsed immediately. This means, for example, that automatic
variables cannot be used in conditional directives, as automatic variables are not set until
the recipe for that rule is invoked. If you need to use automatic variables in a conditional
directive you must move the condition into the recipe and use shell conditional syntax
Rule Definition
Arule is always expanded the same way, regardless of the form:
immediate : immediate ; deferred
GNU make
That is, the target and prerequisite sections are expanded immediately, and the recipe
used to construct the target is always deferred. This general rule is true for explicit rules,
pattern rules, suffix rules, static pattern rules, and simple prerequisite definitions.
3.8 Secondary Expansion
In the previous section we learned that GNU make works in two distinct phases: a read-in
phase and a target-update phase (seeSection3.7[HowmakeReadsaMakefile],page16).
GNU make also has the ability to enable a second expansion of the prerequisites (only) for
some or all targets defined in the makefile. In order for this second expansion to occur,
the special target .SECONDEXPANSION must be defined before the first prerequisite list that
makes use of this feature.
If that special target is defined then in between the two phases mentioned above, right
at the end of the read-in phase, all the prerequisites of the targets defined after the special
target are expanded a second time. In most circumstances this secondary expansion will
have no effect, since all variable and function references will have been expanded during the
initial parsing of the makefiles. In order to take advantage of the secondary expansion phase
of the parser, then, it’s necessary to escape the variable or function reference in the makefile.
In this case the first expansion merely un-escapes the reference but doesn’t expand it, and
expansion is left to the secondary expansion phase. For example, consider this makefile:
ONEVAR = onefile
TWOVAR = twofile
myfile: $(ONEVAR) $$(TWOVAR)
After the first expansion phase the prerequisites list of the myfile target will be onefile
and $(TWOVAR); the first (unescaped) variable reference to ONEVAR is expanded, while
the second (escaped) variable reference is simply unescaped, without being recognized as a
variable reference. Now during the secondary expansion the first word is expanded again
but since it contains no variable or function references it remains the value onefile, while
the second word is now a normal reference to the variable TWOVAR, which is expanded
to the value twofile. The final result is that there are two prerequisites, onefile and
Obviously, this is not a very interesting case since the same result could more easily have
been achieved simply by having both variables appear, unescaped, in the prerequisites list.
One difference becomes apparent if the variables are reset; consider this example:
AVAR = top
onefile: $(AVAR)
twofile: $$(AVAR)
AVAR = bottom
Here the prerequisite of onefile will be expanded immediately, and resolve to the value
top, while the prerequisite of twofile will not be full expanded until the secondary expan-
sion and yield a value of bottom.
This is marginally more exciting, but the true power of this feature only becomes ap-
parent when you discover that secondary expansions always take place within the scope of
the automatic variables for that target. This means that you can use variables such as $@,
Chapter 3: Writing Makefiles
$*, etc. during the second expansion and they will have their expected values, just as in
the recipe. All you have to do is defer the expansion by escaping the $. Also, secondary
expansion occurs for both explicit and implicit (pattern) rules. Knowing this, the possible
uses for this feature increase dramatically. For example:
main_OBJS := main.o try.o test.o
lib_OBJS := lib.o api.o
main lib: $$($$@_OBJS)
Here, after the initial expansion the prerequisites of both the main and lib targets will
be $($@_OBJS). During the secondary expansion, the $@ variable is set to the name of the
target and so the expansion for the main target will yield $(main_OBJS), or main.o try.o
test.o, while the secondary expansion for the lib target will yield $(lib_OBJS), or lib.o
You can also mix in functions here, as long as they are properly escaped:
main_SRCS := main.c try.c test.c
lib_SRCS := lib.c api.c
main lib: $$(patsubst %.c,%.o,$$($$@_SRCS))
This version allows users to specify source files rather than object files, but gives the
same resulting prerequisites list as the previous example.
Evaluation of automatic variables during the secondary expansion phase, especially of
the target name variable $$@, behaves similarly to evaluation within recipes. However, there
are some subtle differences and “corner cases” which come into play for the different types
of rule definitions that make understands. The subtleties of using the different automatic
variables are described below.
Secondary Expansion of Explicit Rules
During the secondary expansion of explicit rules, $$@ and $$% evaluate, respectively, to the
file name of the target and, when the target is an archive member, the target member name.
The $$< variable evaluates to the first prerequisite in the first rule for this target. $$^ and
$$+ evaluate to the list of all prerequisites of rules that have already appeared for the same
target ($$+ with repetitions and $$^ without). The following example will help illustrate
these behaviors:
foo: foo.1 bar.1 $$< $$^ $$+
# line #1
foo: foo.2 bar.2 $$< $$^ $$+
# line #2
foo: foo.3 bar.3 $$< $$^ $$+
# line #3
In the first prerequisite list, all three variables ($$<, $$^, and $$+) expand to the empty
string. In the second, they will have values foo.1, foo.1 bar.1, and foo.1 bar.1 respec-
GNU make
tively. In the third they will have values foo.1, foo.1 bar.1 foo.2 bar.2, and foo.1
bar.1 foo.2 bar.2 foo.1 foo.1 bar.1 foo.1 bar.1 respectively.
Rules undergo secondary expansion in makefile order, except that the rule with the
recipe is always evaluated last.
The variables $$? and $$* are not available and expand to the empty string.
Secondary Expansion of Static Pattern Rules
Rules for secondary expansion of static pattern rules are identical to those for explicit rules,
above, with one exception: for static pattern rules the $$* variable is set to the pattern
stem. As with explicit rules, $$? is not available and expands to the empty string.
Secondary Expansion of Implicit Rules
As make searches for an implicit rule, it substitutes the stem and then performs secondary
expansion for every rule with a matching target pattern. The value of the automatic vari-
ables is derived in the same fashion as for static pattern rules. As an example:
foo: bar
foo foz: fo%: bo%
%oo: $$< $$^ $$+ $$*
When the implicit rule is tried for target foo, $$< expands to bar, $$^ expands to bar
boo, $$+ also expands to bar boo, and $$* expands to f.
Note that the directory prefix (D), as described inSection10.8[Implicit RuleSearch
Algorithm], page 127,isappended(afterexpansion)toallthepatternsintheprerequisites
list. As an example:
%.o: $$(addsuffix /%.c,foo bar) foo.h
@echo $^
The prerequisite list printed, after the secondary expansion and directory prefix recon-
struction, will be /tmp/foo/foo.c /tmp/bar/foo.c foo.h. If you are not interested in this
reconstruction, you can use $$* instead of % in the prerequisites list.
Documents you may be interested
Documents you may be interested