Lines Matching refs:expanded
266 * Value Function:: Return the un-expanded value of a variable.
1019 variable. When the variable is expanded they will either be treated
1100 expanded. @xref{Using Variables, ,How to Use Variables}.
1256 Variables}, for more information on simply-expanded (@code{:=})
1339 @c The second special variable is @code{.TARGETS}. When expanded, the
1593 A rule is always expanded the same way, regardless of the form:
1600 That is, the target and prerequisite sections are expanded immediately,
1623 expanded a @emph{second time}. In most circumstances this secondary
1625 references will have been expanded during the initial parsing of the
1642 first (unescaped) variable reference to @var{ONEVAR} is expanded,
1645 secondary expansion the first word is expanded again but since it
1648 to the variable @var{TWOVAR}, which is expanded to the value
1665 Here the prerequisite of @file{onefile} will be expanded immediately,
1667 @file{twofile} will not be full expanded until the secondary expansion
2056 Wildcards can be used in the commands of a rule, where they are expanded
2465 rebuilt using the expanded path.
2905 will be expanded a second time after all makefiles have been read in.
3704 commands for targets which are not rebuilt are never expanded.
4338 @code{unexport} are expanded, and so could be variables or functions
4677 Because variables defined by @code{define} are recursively expanded
4679 are expanded now. For example:
4785 Variables and functions in all parts of a makefile are expanded when
4889 @cindex recursively expanded variables
4890 @cindex variables, recursively expanded
4894 distinguished in how they are defined and in what they do when expanded.
4897 The first flavor of variable is a @dfn{recursively expanded} variable.
4902 these references are expanded whenever this variable is substituted (in
4930 will do what was intended: when @samp{CFLAGS} is expanded in a command,
4947 expanded. This makes @code{make} run slower; worse, it causes the
4952 To avoid all the problems and inconveniences of recursively expanded
4953 variables, there is another flavor: simply expanded variables.
4955 @cindex simply expanded variables
4956 @cindex variables, simply expanded
4958 @dfn{Simply expanded variables} are defined by lines using @samp{:=}
4960 The value of a simply expanded variable is scanned
4963 expanded variable is the result of expanding the text that you write.
4981 When a simply expanded variable is referenced, its value is substituted
5015 Simply expanded variables generally make complicated makefile programming
5198 References to recursively-expanded variables within a variable name are
5337 @dfn{recursively expanded variables}
5392 Variables defined with @samp{=} are @dfn{recursively expanded} variables.
5393 Variables defined with @samp{:=} are @dfn{simply expanded} variables; these
5394 definitions can contain variable references which will be expanded before
5398 are expanded when the line is read to find the actual variable name to use.
5469 acts just like normal @samp{=}: it defines a recursively-expanded
5478 making it a simply-expanded variable, @samp{+=} adds to that
5479 simply-expanded definition, and expands the new text before appending it
5499 first to be recursively-expanded using plain @samp{=}, @code{make} does
5501 recursively-expanded variable, @code{make} does not expand the value you set
5503 verbatim, and saves these variable and function references to be expanded
5505 of Variables}). When you use @samp{+=} on a recursively-expanded variable,
5541 Using @samp{=} for the definition makes @code{CFLAGS} a recursively-expanded
5542 variable, meaning @w{@samp{$(includes) -O}} is @emph{not} expanded when
5554 redefines @code{CFLAGS} as a simply-expanded variable; this means
5646 works just like @samp{=}: it creates a recursively-expanded variable
5649 are expanded when the directive is read to find the actual variable name
6067 is expanded, so it could be a variable or function that expands
6078 The variable reference @code{$(foo)} is expanded, yielding @code{bar},
6080 @code{bar} is not expanded, but its value is examined to determine if
6202 * Value Function:: Return the un-expanded value of a variable.
6802 expanded initially. Only those arguments which need to be expanded,
6803 will be expanded.
6814 trailing whitespace stripped, then is expanded. If it expands to any
6834 Each argument is expanded, in order. If an argument expands to a
6836 is that string. If, after all arguments are expanded, all of them are
6842 Each argument is expanded, in order. If an argument expands to an
6866 The first two arguments, @var{var} and @var{list}, are expanded before
6868 @strong{not} expanded at the same time. Then for each word of the expanded
6869 value of @var{list}, the variable named by the expanded value of @var{var}
6870 is set to that word, and @var{text} is expanded. Presumably @var{text}
6874 The result is that @var{text} is expanded as many times as there are
6912 a simply-expanded variable would not do, since @code{wildcard} would be
6919 @code{foreach}. The variable @var{var} is a simply-expanded variable
6960 Then @var{variable} is expanded as a @code{make} variable in the context
7037 variable @emph{without} having it expanded. Please note that this
7039 you create a simply expanded variable its value is expanded during the
7071 expanded as a @code{make} variable, while the second output line would
7088 @code{eval} function is expanded, then the results of that expansion
7089 are parsed as makefile syntax. The expanded results can define new
7096 It's important to realize that the @code{eval} argument is expanded
7098 that expansion are expanded again when they are parsed as makefile
7286 if @var{variable} is a recursively expanded variable.
7290 if @var{variable} is a simply expanded variable.
7316 function calls are expanded (@pxref{Reading Makefiles, , How
7320 expanded variables vs.@: simply expanded variables (@pxref{Flavors, ,The
7361 expanded before the error is generated.
7391 except that @code{make} doesn't exit. Instead, @var{text} is expanded
7400 This function does nothing more than print its (expanded) argument(s)
7816 a recursively-expanded variable or a simply-expanded variable. The
7817 examples shown above make a recursively-expanded variable; to make a
7818 simply-expanded variable, write @samp{:=} instead of @samp{=}. But, unless
10092 Simply-expanded variables. @xref{Flavors, ,The Two Flavors of Variables}.
10314 Define a multi-line, recursively-expanded variable.@*
10758 @var{xxx} that, when it's expanded, will refer to itself (@var{xxx}).
10759 This is not allowed; either use simply-expanded variables (@code{:=}) or