convert byte array to pdf mvc : Embed pdf into html software control project winforms web page windows UWP make7-part1951

Chapter 6: How to Use Variables
Simply expanded variables are definedby lines using‘:=’or ‘::=’(seeSection6.5[Setting
Variables], page 65). BothformsareequivalentinGNUmake;howeveronlythe‘::=’form
is described by the POSIX standard (support for ‘::=’ was added to the POSIX standard
in 2012, so older versions of make won’t accept this form either).
The value of a simply expanded variable is scanned once and for all, expanding any
references to other variables and functions, when the variable is defined. The actual value
of the simply expanded variable is the result of expanding the text that you write. It does
not contain any references to other variables; it contains their values as of the time this
variable was defined. Therefore,
x := foo
y := $(x) bar
x := later
is equivalent to
y := foo bar
x := later
When a simply expanded variable is referenced, its value is substituted verbatim.
Here is a somewhat more complicated example, illustrating the use of ‘:=’ in conjunction
with the shell function. (SeeSection8.13[TheshellFunction],page97.) This example
also shows use of the variable MAKELEVEL, which is changed when it is passed down from
level to level. (See Section5.7.2 [CommunicatingVariables to aSub-make],page 52, for
information about MAKELEVEL.)
ifeq (0,${MAKELEVEL})
:= $(shell whoami)
host-type := $(shell arch)
MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
An advantage of this use of ‘:=’ is that a typical ‘descend into a directory’ recipe then looks
like this:
${MAKE} -C $@ all
Simply expanded variables generally make complicated makefile programming more pre-
dictable because they work like variables in most programming languages. They allow you
to redefine a variable using its own value (or its value processed in some way by one of
the expansion functions) and to use the expansion functions much more efficiently (see
Chapter 8 [Functions for Transforming Text], page 83).
You can also use them to introduce controlled leading whitespace into variable values.
Leading whitespace characters are discarded from your input before substitution of variable
references and function calls; this means you can include leading spaces in a variable value
by protecting them with variable references, like this:
nullstring :=
space := $(nullstring) # end of the line
Here the value of the variable space is precisely one space.
The comment
‘# end of the line’ is included here just for clarity. Since trailing space characters are not
stripped from variable values, just a space at the end of the line would have the same
Embed pdf into html - software control project: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
Embed pdf into html - software control project: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
effect (but be rather hard to read). If you put whitespace at the end of a variable value,
it is a good idea to put a comment like that at the end of the line to make your intent
clear. Conversely, if you do not want any whitespace characters at the end of your variable
value, you must remember not to put a random comment on the end of the line after some
whitespace, such as this:
dir := /foo/bar
# directory to put the frobs in
Here the value of the variable dir is ‘/foo/bar ’ (with four trailing spaces), which was
probably not the intention. (Imagine something like ‘$(dir)/file’ with this definition!)
There is another assignment operator for variables, ‘?=’. This is called a conditional
variable assignment operator, because it only has an effect if the variable is not yet defined.
This statement:
FOO ?= bar
is exactly equivalent to this (seeSection8.10[TheoriginFunction],page94):
ifeq ($(origin FOO), undefined)
FOO = bar
Note that a variable set to an empty value is still defined, so ‘?=’ will not set that
6.3 Advanced Features for Reference to Variables
This section describes some advanced features you can use to reference variables in more
flexible ways.
6.3.1 Substitution References
Asubstitution reference substitutes the value of a variable withalterations that you specify.
It has the form ‘$(var:a=b)’ (or ‘${var:a=b}’) and its meaning is to take the value of the
variable var, replace every a at the end of a word with b in that value, and substitute the
resulting string.
When we say “at the end of a word”, we mean that a must appear either followed by
whitespace or at the end of the value in order to be replaced; other occurrences of a in the
value are unaltered. For example:
foo := a.o b.o c.o
bar := $(foo:.o=.c)
sets ‘bar’ to ‘a.c b.c c.c’. SeeSection6.5[SettingVariables],page65.
Asubstitution reference is actually an abbreviation for use of the patsubst expansion
function (seeSection8.2[Functions for String SubstitutionandAnalysis],page84). We
provide substitution references as well as patsubst for compatibility with other implemen-
tations of make.
Another type of substitution reference lets you use the full power of the patsubst func-
tion. It has the same form ‘$(var:a=b)’ described above, except that now a must contain a
single ‘%’ character. This case is equivalent to ‘$(patsubst a,b,$(var))’. SeeSection8.2
[Functions for String Substitution and Analysis], page 84,foradescriptionofthepatsubst
software control project:C# TIFF: How to Embed, Remove, Add and Update TIFF Color Profile
On the whole, our SDK supports the following manipulations. Empower C# programmers to embed, remove, add and update ICCProfile. Support
software control project:VB.NET PDF Convert to Images SDK: Convert PDF to png, gif images
Embed PDF to image converter in viewer. Quick evaluation source codes for VB.NET class. Sometimes, to convert PDF document into BMP, GIF, JPEG and PNG
Chapter 6: How to Use Variables
For example:
foo := a.o b.o c.o
bar := $(foo:%.o=%.c)
sets ‘bar’ to ‘a.c b.c c.c’.
6.3.2 Computed Variable Names
Computed variable names are a complicated concept needed only for sophisticated makefile
programming. For most purposes you need not consider them, except to know that making
avariable with a dollar sign in its name might have strange results. However, if you are the
type that wants to understand everything, or you are actually interested in what they do,
read on.
Variables may be referenced inside the name of a variable. This is called a computed
variable name or a nested variable reference. For example,
x = y
y = z
a := $($(x))
defines a as ‘z’: the ‘$(x)’ inside ‘$($(x))’ expands to ‘y’, so ‘$($(x))’ expands to ‘$(y)’
which in turn expands to ‘z’. Here the name of the variable to reference is not stated
explicitly; it is computed by expansion of ‘$(x)’. The reference ‘$(x)’ here is nested within
the outer variable reference.
The previous example shows two levels of nesting, but any number of levels is possible.
For example, here are three levels:
x = y
y = z
z = u
a := $($($(x)))
Here the innermost ‘$(x)’ expands to ‘y’, so ‘$($(x))’ expands to ‘$(y)’ which in turn
expands to ‘z’; now we have ‘$(z)’, which becomes ‘u’.
References to recursively-expanded variables within a variable name are re-expanded in
the usual fashion. For example:
x = $(y)
y = z
z = Hello
a := $($(x))
defines a as ‘Hello’: ‘$($(x))’ becomes ‘$($(y))’ which becomes ‘$(z)’ which becomes
Nested variable references can also contain modified references and function invocations
(seeChapter8[FunctionsforTransformingText],page83), just like any other reference.
For example, using the subst function (seeSection8.2[FunctionsforStringSubstitution
and Analysis], page 84):
software control project:C# Raster - Image Save Options in C#.NET
NET Read: PDF Image Extract; VB.NET Write: Insert text into PDF; VB.NET How-to, VB.NET PDF, VB.NET Word, VB a zone bit of whether it's need to embed Color profile
software control project:C# TIFF: How to Insert & Burn Picture/Image into TIFF Document
Entire C# Code to Embed and Burn Image to TIFF GetPage(0); // load an PNG logo into REImage REImage powerful & profession imaging controls, PDF document, tiff
GNU make
x = variable1
variable2 := Hello
y = $(subst 1,2,$(x))
z = y
a := $($($(z)))
eventually defines a as ‘Hello’. It is doubtfulthat anyone would ever want to write a nested
reference as convoluted as this one, but it works: ‘$($($(z)))’ expands to ‘$($(y))’ which
becomes ‘$($(subst 1,2,$(x)))’. This gets the value ‘variable1’ from x and changes it
by substitution to ‘variable2’, so that the entire string becomes ‘$(variable2)’, a simple
variable reference whose value is ‘Hello’.
Acomputed variable name need not consist entirely of a single variable reference. It can
contain several variable references, as well as some invariant text. For example,
a_dirs := dira dirb
1_dirs := dir1 dir2
a_files := filea fileb
1_files := file1 file2
ifeq "$(use_a)" "yes"
a1 := a
a1 := 1
ifeq "$(use_dirs)" "yes"
df := dirs
df := files
dirs := $($(a1)_$(df))
will give dirs the same value as a_dirs, 1_dirs, a_files or 1_files depending on the
settings of use_a and use_dirs.
Computed variable names can also be used in substitution references:
a_objects := a.o b.o c.o
1_objects := 1.o 2.o 3.o
sources := $($(a1)_objects:.o=.c)
defines sources as either ‘a.c b.c c.c’ or ‘1.c 2.c 3.c’, depending on the value of a1.
The only restriction on this sort of use of nested variable references is that they cannot
specify part of the name of a function to be called. This is because the test for a recognized
function name is done before the expansion of nested references. For example,
software control project:VB.NET TIFF: Rotate TIFF Page by Using RaterEdge .NET TIFF
formats are: JPEG, PNG, GIF, BMP, PDF, Word (Docx Visual Basic .NET class, and then embed "RasterEdge.Imaging splitting huge target TIFF file into multiple and
software control project:VB.NET Image: How to Draw and Cutomize Text Annotation on Image
NET text annotation add-on tutorial can be divided into a few on document files in VB.NET, including PDF, TIFF & license and at last you can embed the required
Chapter 6: How to Use Variables
ifdef do_sort
func := sort
func := strip
bar := a d b g q c
foo := $($(func) $(bar))
attempts to give ‘foo’ the value of the variable ‘sort a d b g q c’ or ‘strip a d b g q c’,
rather than giving ‘a d b g q c’ as the argument to either the sort or the strip function.
This restriction could be removed in the future if that change is shown to be a good idea.
You can also use computed variable names in the left-hand side of a variable assignment,
or in a define directive, as in:
dir = foo
$(dir)_sources := $(wildcard $(dir)/*.c)
define $(dir)_print =
lpr $($(dir)_sources)
This example defines the variables ‘dir’, ‘foo_sources’, and ‘foo_print’.
Note that nested variable references are quite different from recursively expanded vari-
ables (see Section 6.2 [The e Two Flavors of Variables], , page 60), though both are used
together in complex ways when doing makefile programming.
6.4 How Variables Get Their Values
Variables can get values in several different ways:
 You can specify an overriding value when you run make. SeeSection9.5[Overriding
Variables], page 103.
 You can specify a value in the makefile, either with an assignment (see Section6.5
[Setting Variables], page 65) or withaverbatimdefinition(see Section 6.8 [Defining
Multi-Line Variables], page 69).
 Variables in the environment become make variables. SeeSection6.10[Variablesfrom
the Environment], page 70.
 Several automatic variables are given new values for each rule. Each of these has a
single conventional use. SeeSection10.5.3[AutomaticVariables],page120.
 Several variables have constant initial values. See Section 10.3 [Variables s Used d by
Implicit Rules], page 115.
6.5 Setting Variables
To set a variable from the makefile, write a line starting with the variable name followed
by ‘=’ ‘:=’, or ‘::=’. Whatever follows the ‘=’, ‘:=’, or ‘::=’ on the line becomes the value.
For example,
objects = main.o foo.o bar.o utils.o
software control project:VB.NET Image: VB.NET Code to Add Rubber Stamp Annotation to Image
Suitable for VB.NET PDF, Word & TIFF document managing & editing project. VB Can be implemented into both Windows and web VB.NET applications; Support single or
software control project:C# PDF url edit Library: insert, remove PDF links in, ASP.
and active html links in .NET WinForms. Able to insert and delete PDF links. Able to embed link to specific PDF pages. Easy to put link into specified position
GNU make
defines a variable named objects. Whitespace around the variable name and immediately
after the ‘=’ is ignored.
Variables defined with ‘=’ are recursively expanded variables. Variables defined with
‘:=’ or ‘::=’ are simply expanded variables; these definitions can contain variable references
which will be expanded before the definition is made. SeeSection6.2[TheTwoFlavorsof
Variables], page 60.
The variable name may contain function and variable references, which are expanded
when the line is read to find the actual variable name to use.
There is no limit on the length of the value of a variable except the amount of memory
on the computer. You can split the value of a variable into multiple physical lines for
readability (seeSection3.1.1[SplittingLongLines],page12).
Most variable names are considered to have the empty string as a value if you have never
set them. Several variables have built-in initial values that are not empty, but you can set
them in the usual ways (see Section10.3[Variables Usedby Implicit Rules], , page 115).
Several special variables are set automatically to a new value for each rule; these are called
the automatic variables (seeSection10.5.3[AutomaticVariables],page120).
If you’d like a variable to be set to a value only if it’s not already set, then you can
use the shorthand operator ‘?=’ instead of ‘=’. These two settings of the variable ‘FOO’ are
identical (seeSection8.10[TheoriginFunction],page94):
FOO ?= bar
ifeq ($(origin FOO), undefined)
FOO = bar
The shell assignment operator ‘!=’ can be used to execute a program and set a variable
to its output. This operator first evaluates the right-hand side, then passes that result to
the shell for execution. If the result of the execution ends in a newline, that one newline is
removed; all other newlines are replaced by spaces. The resulting string is then placed into
the named recursively-expanded variable. For example:
hash != printf ’\043’
file_list != find . -name ’*.c’
If the result of the execution could produce a $, and you don’t intend what follows that
to be interpreted as a make variable or function reference, then you must replace every $
with $$ as part of the execution. Alternatively, you can set a simply expanded variable to
the result of running a program using the shell function call. SeeSection8.13[Theshell
Function], page 97. Forexample:
hash := $(shell printf ’\043’)
var := $(shell find . -name "*.c")
6.6 Appending More Text to Variables
Often it is useful to add more text to the value of a variable already defined. You do this
with a line containing ‘+=’, like this:
objects += another.o
Chapter 6: How to Use Variables
This takes the value of the variable objects, and adds the text ‘another.o’ to it (preceded
by a single space). Thus:
objects = main.o foo.o bar.o utils.o
objects += another.o
sets objects to ‘main.o foo.o bar.o utils.o another.o’.
Using ‘+=’ is similar to:
objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o
but differs in ways that become important when you use more complex values.
When the variable in question has not been defined before, ‘+=’ acts just like normal
‘=’: it defines a recursively-expanded variable. However, when there is a previous defini-
tion, exactly what ‘+=’ does depends on what flavor of variable you defined originally. See
Section 6.2 [The Two Flavors of Variables], page 60,foranexplanationofthetwoflavors
of variables.
When you add to a variable’s value with ‘+=’, make acts essentially as if you had included
the extra text in the initialdefinition of the variable. If you defined it first with‘:=’ or ‘::=’,
making it a simply-expanded variable, ‘+=’ adds to that simply-expanded definition, and
expands the new text before appending it to the old value just as ‘:=’ does (seeSection6.5
[Setting Variables], page 65,forafullexplanationof‘:=’or‘::=’).Infact,
variable := value
variable += more
is exactly equivalent to:
variable := value
variable := $(variable) more
On the other hand, when you use ‘+=’ with a variable that you defined first to be
recursively-expanded using plain ‘=’, make does something a bit different. Recall that when
you define a recursively-expanded variable, make does not expand the value you set for
variable and function references immediately. Instead it stores the text verbatim, and saves
these variable and function references to be expanded later, when you refer to the new
variable (seeSection6.2[TheTwoFlavorsofVariables],page60). When you use ‘+=’ on
arecursively-expanded variable, it is this unexpanded text to which make appends the new
text you specify.
variable = value
variable += more
is roughly equivalent to:
temp = value
variable = $(temp) more
except that of course it never defines a variable called temp. The importance of this comes
when the variable’s old value contains variable references. Take this common example:
CFLAGS = $(includes) -O
CFLAGS += -pg # enable profiling
GNU make
The first line defines the CFLAGS variable with a reference to another variable, includes.
(CFLAGS is used by the rules for C compilation; see Section10.2 [Catalogue of f Built-In
Rules], page 112.) Using‘=’forthedefinitionmakesCFLAGSarecursively-expandedvariable,
meaning ‘$(includes) -O’ is not expanded when make processes the definition of CFLAGS.
Thus, includes need not be defined yet for its value to take effect. It only has to be defined
before any reference to CFLAGS. If we tried to append to the value of CFLAGS without using
‘+=’, we might do it like this:
CFLAGS := $(CFLAGS) -pg # enable profiling
This is pretty close, but not quite what we want. Using ‘:=’ redefines CFLAGS as a simply-
expanded variable; this means make expands the text ‘$(CFLAGS) -pg’ before setting the
variable. If includes is not yet defined, we get ‘ -O -pg’, and a later definition of includes
will have no effect. Conversely, by using ‘+=’ we set CFLAGS to the unexpanded value
‘$(includes) -O -pg’. Thus we preserve the reference to includes, so if that variable gets
defined at any later point, a reference like ‘$(CFLAGS)’ still uses its value.
6.7 The override Directive
If a variable has been set with a command argument (seeSection9.5[OverridingVariables],
page 103),thenordinary assignmentsinthemakefileareignored. . If f youwanttosetthe
variable in the makefile even though it was set with a command argument, you can use an
override directive, which is a line that looks like this:
override variable = value
override variable := value
To append more text to a variable defined on the command line, use:
override variable += more text
Variable assignments marked with the override flag have a higher priority than all other
assignments, except another override. Subsequent assignments or appends to this variable
which are not marked override will be ignored.
The override directive was not invented for escalation in the war between makefiles
and command arguments. It was invented so you can alter and add to values that the user
specifies with command arguments.
For example, suppose you always want the ‘-g’ switch when you run the C compiler, but
you would like to allow the user to specify the other switches with a command argument
just as usual. You could use this override directive:
override CFLAGS += -g
You can also use override directives with define directives. This is done as you might
override define foo =
See the next section for information about define.
Chapter 6: How to Use Variables
6.8 Defining Multi-Line Variables
Another way to set the value of a variable is to use the define directive. This directive
has an unusual syntax which allows newline characters to be included in the value, which
is convenient for defining both canned sequences of commands (see Section5.8[Defining
Canned Recipes], page 56), and also sections s of makefile e syntax x to use e with h eval (see
Section 8.9 [Eval Function], page 93).
The define directive is followed on the same line by the name of the variable being
defined and an (optional) assignment operator, and nothing more. The value to give the
variable appears on the following lines. The end of the value is marked by a line containing
just the word endef. Aside from this difference in syntax, define works just like any other
variable definition. The variable name may contain function and variable references, which
are expanded when the directive is read to find the actual variable name to use.
You may omit the variable assignment operator if you prefer. If omitted, make assumes
it to be ‘=’ and creates a recursively-expanded variable (seeSection6.2[TheTwoFlavors
of Variables], page 60). Whenusinga‘+=’operator,thevalueisappendedtotheprevious
value as with any other append operation: with a single space separating the old and new
You may nest define directives: make will keep track of nested directives and report
an error if they are not all properly closed with endef. Note that lines beginning with
the recipe prefix character are considered part of a recipe, so any define or endef strings
appearing on such a line will not be considered make directives.
define two-lines =
echo foo
echo $(bar)
The value in an ordinary assignment cannot contain a newline; but the newlines that
separate the lines of the value in a define become part of the variable’s value (except for
the final newline which precedes the endef and is not considered part of the value).
When used in a recipe, the previous example is functionally equivalent to this:
two-lines = echo foo; echo $(bar)
since two commands separated by semicolon behave much like two separate shellcommands.
However, note that using two separate lines means make will invoke the shell twice, running
an independent sub-shell for each line. SeeSection5.3[RecipeExecution],page44.
If you want variable definitions made with define to take precedence over command-line
variable definitions, you can use the override directive together with define:
override define two-lines =
6.9 Undefining Variables
If you want to clear a variable, setting its value to empty is usually sufficient. Expanding
such a variable will yield the same result (empty string) regardless of whether it was set or
GNU make
not. However, if you are using the flavor (seeSection8.11[FlavorFunction],page95) and
origin (seeSection8.10[OriginFunction],page94) functions, there is a difference between
avariable that was never set and a variable with an empty value. In such situations you
may want to use the undefine directive to make a variable appear as if it was never set.
For example:
foo := foo
bar = bar
undefine foo
undefine bar
$(info $(origin foo))
$(info $(flavor bar))
This example will print “undefined” for both variables.
If you want to undefine a command-line variable definition, you can use the override
directive together with undefine, similar to how this is done for variable definitions:
override undefine CFLAGS
6.10 Variables from the Environment
Variables in make can come from the environment in which make is run. Every environment
variable that make sees when it starts up is transformed into a make variable with the same
name and value. However, an explicit assignment in the makefile, or with a command
argument, overrides the environment. (If the ‘-e’ flag is specified, then values from the
environment override assignments in the makefile. SeeSection9.7[Summary ofOptions],
page 104.Butthisisnotrecommendedpractice.)
Thus, by setting the variable CFLAGS in your environment, you can cause all C compi-
lations in most makefiles to use the compiler switches you prefer. This is safe for variables
with standard or conventional meanings because you know that no makefile will use them
for other things. (Note this is not totally reliable; some makefiles set CFLAGS explicitly and
therefore are not affected by the value in the environment.)
When make runs a recipe, variables defined in the makefile are placed into the environ-
ment of each shell. This allows you to pass values to sub-make invocations (seeSection5.7
[Recursive Use of make], page 50). Bydefault,onlyvariablesthatcamefromtheenviron-
ment or the command line are passed to recursive invocations. You can use the export
directive to pass other variables. See Section5.7.2[CommunicatingVariables toa Sub-
make], page 52,forfulldetails.
Other use of variables from the environment is not recommended. It is not wise for
makefiles to depend for their functioning on environment variables set up outside their
control, since this wouldcause different users to get different results from the same makefile.
This is against the whole purpose of most makefiles.
Such problems would be especially likely with the variable SHELL, which is normally
present in the environment to specify the user’s choice of interactive shell. It would be very
undesirable for this choice to affect make; so, make handles the SHELL environment variable
in a special way; seeSection5.3.2[ChoosingtheShell],page45.
Documents you may be interested
Documents you may be interested