Lines Matching full:variable
114 * MAKEFILES Variable:: The environment can specify extra makefiles.
115 * MAKEFILE_LIST Variable:: Discover which makefiles have been read.
195 * MAKE Variable:: The special effects of using `$(MAKE)'.
203 * Reference:: How to use the value of a variable.
205 * Advanced:: Advanced features for referencing a variable.
207 * Setting:: How to set a variable in the makefile.
209 of a variable.
210 * Override Directive:: How to set a variable in the makefile even if
212 * Defining:: An alternate way to set a variable
214 * Environment:: Variable values can come from the environment.
215 * Target-specific:: Variable values can be defined on a per-target
217 * Pattern-specific:: Target-specific variable values can be applied
222 * Substitution Refs:: Referencing a variable with
224 * Computed Names:: Computing the name of the variable to refer to.
240 * Value Function:: Return the un-expanded value of a variable.
242 * Origin Function:: Find where a variable got its value.
243 * Flavor Function:: Find out the flavor of a variable.
257 * Overriding:: How to override a variable to specify
589 Specify the Goals: Goals.) or with the `.DEFAULT_GOAL' special variable
649 eliminate the risk and simplify the makefile by using a variable.
653 It is standard practice for every makefile to have a variable named
655 of all object file names. We would define such a variable `objects'
662 substitute the variable's value by writing `$(objects)' (*note How to
666 variable for the object files:
711 variable `objects' as suggested above:
821 * MAKEFILES Variable:: The environment can specify extra makefiles.
822 * MAKEFILE_LIST Variable:: Discover which makefiles have been read.
837 rules", "variable definitions", "directives", and "comments". Rules,
852 * A "variable definition" is a line that specifies a text string
853 value for a variable that can be substituted into the text later.
854 The simple makefile example shows a variable definition for
868 * Defining a variable from a verbatim string containing
886 definition of the variable, but rather kept intact in the value of
887 the variable. When the variable is expanded they will either be
889 the context in which the variable is evaluated.
924 File: make.info, Node: Include, Next: MAKEFILES Variable, Prev: Makefile Names, Up: Makefiles
943 allowed at the end of the line. If the file names contain any variable
964 common set of variable definitions (*note Setting Variables: Setting.)
1009 File: make.info, Node: MAKEFILES Variable, Next: MAKEFILE_LIST Variable, Prev: Include, Up: Makefiles
1011 3.4 The Variable `MAKEFILES'
1014 If the environment variable `MAKEFILES' is defined, `make' considers
1024 usually is not desirable to set the environment variable before a
1038 File: make.info, Node: MAKEFILE_LIST Variable, Next: Special Variables, Prev: MAKEFILES Variable, Up: Makefiles
1040 3.5 The Variable `MAKEFILE_LIST'
1044 `MAKEFILES' variable, the command line, the default files, or from
1046 `MAKEFILE_LIST' variable. They are added right before `make' begins to
1050 last word in this variable, it will be the name of the current makefile.
1073 Flavors, for more information on simply-expanded (`:=') variable
1077 File: make.info, Node: Special Variables, Next: Remaking Makefiles, Prev: MAKEFILE_LIST Variable, Up: Makefiles
1089 The `.DEFAULT_GOAL' variable allows you to discover the current
1126 This variable is set only if this instance of `make' has restarted
1130 variable). You should not set, modify, or export this variable.
1138 you assign to this variable will be ignored; it will always return
1169 Supports target-specific and pattern-specific variable
1170 assignments. *Note Target-specific Variable Values:
1265 one in the other, and add more targets or variable definitions.
1317 direct impact on how variable and function expansion happens; this is
1332 Variable Assignment
1335 Variable definitions are parsed as follows:
1347 immediate if the variable was previously set as a simple variable
1393 expansion will have no effect, since all variable and function
1396 of the parser, then, it's necessary to _escape_ the variable or
1409 (unescaped) variable reference to ONEVAR is expanded, while the second
1410 (escaped) variable reference is simply unescaped, without being
1411 recognized as a variable reference. Now during the secondary expansion
1412 the first word is expanded again but since it contains no variable or
1414 second word is now a normal reference to the variable TWOVAR, which is
1452 expansion, the `$@' variable is set to the name of the target and so
1471 phase, especially of the target name variable `$$@', behaves similarly
1483 variable evaluates to the first prerequisite in the first rule for this
1514 rules the `$$*' variable is set to the pattern stem. As with explicit
1661 Because dollar signs are used to start `make' variable references,
1743 simulated by setting the environment variable HOME.
1783 Files to Record Events: Empty Targets. (The automatic variable `$?' is
1787 Wildcard expansion does not happen when you define a variable.
1792 then the value of the variable `objects' is the actual string `*.o'.
1851 expansion does not normally take place when a variable is set, or
1922 The value of the `make' variable `VPATH' specifies a list of
1936 In the `VPATH' variable, directory names are separated by colons or
1966 Similar to the `VPATH' variable, but more selective, is the `vpath'
1981 `VPATH' variable.
2008 (and before) the directories in the `VPATH' variable.
2088 directories, you can use the `GPATH' variable to indicate this to
2118 (The variable `CFLAGS' exists so you can specify flags for C
2124 not want to mention in the commands. The automatic variable `$<' is
2187 and `libNAME.a', this is customizable via the `.LIBPATTERNS' variable.
2188 Each word in the value of this variable is a pattern string. When a
2198 variable to an empty value.
2251 often contain a variable which lists a number of subdirectories to be
2394 variable `$?' is used to print only those files that have changed
2569 need to be absolutely identical, since the automatic variable `$@'
2589 target, much as the variable `$@' allows you to vary the commands. You
2617 a variable, such as `objects', containing a list of all the compiler
2632 specified with a variable that you set with a command argument to `make'
2720 Here `$<' is the automatic variable that holds the name of the
2721 prerequisite and `$@' is the automatic variable that holds the name of
2919 (This example uses a substitution variable reference to translate the
2976 started until another rule or variable definition) will be considered a
2989 * A variable definition in a "rule context" which is indented by a
2991 command line, not a `make' variable definition, and passed to the
3075 the quoted string, or even the entire command, into a `make' variable
3076 then use the variable in the command. In this situation the newline
3090 Target-specific Variable Values: Target-specific.) to obtain a tighter
3091 correspondence between the variable and the command that uses it.
3100 variable references in them (*note Basics of Variable References:
3105 Variable and function references in commands have identical syntax
3110 clear in your mind whether the variable you want to reference is a
3111 `make' variable (use a single dollar sign) or a shell variable (use two
3204 The program used as the shell is taken from the variable `SHELL'. If
3205 this variable is not set in your makefile, the program `/bin/sh' is
3208 Unlike most variables, the variable `SHELL' is never set from the
3209 environment. This is because the `SHELL' environment variable is used
3225 this variable, and therefore it is most likely set specifically to be
3227 for `make', you can set the variable `MAKESHELL' to the shell that
3237 On MS-DOS, if `SHELL' is not set, the value of the variable
3240 The processing of lines that set the variable `SHELL' in Makefiles
3259 3. In each of the directories in the `PATH' variable, in order.
3497 any `-C' options) it sets the variable `CURDIR' to the pathname of the
3502 default, an environment variable `CURDIR' will not override this
3503 value). Note that setting this variable has no impact on the operation
3509 * MAKE Variable:: The special effects of using `$(MAKE)'.
3516 File: make.info, Node: MAKE Variable, Next: Variables/Recursion, Prev: Recursion, Up: Recursion
3518 5.7.1 How the `MAKE' Variable Works
3521 Recursive `make' commands should always use the variable `MAKE', not
3527 The value of this variable is the file name with which `make' was
3533 As a special feature, using the variable `MAKE' in the commands of a
3535 or `-q' (`--question') option. Using the `MAKE' variable has the same
3538 special feature is only enabled if the `MAKE' variable appears directly
3539 in the command script: it does not apply if the `MAKE' variable is
3540 referenced through expansion of another variable. In the latter case
3552 line of a rule contains the variable `MAKE', the flags `-t', `-n' and
3561 File: make.info, Node: Variables/Recursion, Next: Options/Recursion, Prev: MAKE Variable, Up: Recursion
3566 Variable values of the top-level `make' can be passed to the sub-`make'
3572 To pass down, or "export", a variable, `make' adds the variable and
3574 in turn, uses the environment to initialize its table of variable
3577 Except by explicit request, `make' exports a variable only if it is
3580 Some shells cannot cope with environment variable names consisting of
3583 The value of the `make' variable `SHELL' is not exported. Instead,
3584 the value of the `SHELL' variable from the invoking environment is
3589 The special variable `MAKEFLAGS' is always exported (unless you
3592 `make' automatically passes down variable values that were defined
3593 on the command line, by putting them in the `MAKEFLAGS' variable.
3603 export VARIABLE ...
3605 If you want to _prevent_ a variable from being exported, use the
3608 unexport VARIABLE ...
3612 (list of) variable names to be (un)exported.
3614 As a convenience, you can define a variable and export it at the same
3617 export VARIABLE = value
3621 VARIABLE = value
3622 export VARIABLE
3626 export VARIABLE := value
3630 VARIABLE := value
3631 export VARIABLE
3635 export VARIABLE += value
3639 VARIABLE += value
3640 export VARIABLE
3653 an `export' or `unexport' directive should be exported. Any variable
3675 As a special feature, the variable `MAKELEVEL' is changed when it is
3676 passed down from level to level. This variable's value is a string
3687 You can use the variable `MAKEFILES' to cause all sub-`make'
3689 whitespace-separated list of file names. This variable, if defined in
3692 before the usual or specified ones. *Note The Variable `MAKEFILES':
3693 MAKEFILES Variable.
3702 through the variable `MAKEFLAGS'. This variable is set up
3714 contain `=', `make' treats as variable definitions just as if they
3744 The command line variable definitions really appear in the variable
3745 `MAKEOVERRIDES', and `MAKEFLAGS' contains a reference to this variable.
3747 the command line variable definitions, you can reset `MAKEOVERRIDES' to
3760 A similar variable `MFLAGS' exists also, for historical
3762 does not contain the command line variable definitions, and it always
3776 The `MAKEFLAGS' variable can also be useful if you want to have
3782 variable is set only for compatibility; `make' does not interpret a
3835 canned sequence is actually a variable, so the name must not conflict
3836 with other variable names.
3845 Here `run-yacc' is the name of the variable being defined; `endef'
3847 The `define' directive does not expand variable references and function
3848 calls in the canned sequence; the `$' characters, parentheses, variable
3849 names, and so on, all become part of the value of the variable you are
3858 To use the canned sequence, substitute the variable into the
3859 commands of a rule. You can substitute it like any other variable
3860 (*note Basics of Variable References: Reference.). Because variables
3862 variable references you wrote inside the `define' are expanded now.
3868 `foo.y' will be substituted for the variable `$^' when it occurs in
3936 A "variable" is a name defined in a makefile to represent a string of
3937 text, called the variable's "value". These values are substituted by
3944 variable definitions using `=', and the bodies of variable definitions
3951 A variable name may be any sequence of characters not containing `:',
3952 `#', `=', or leading or trailing whitespace. However, variable names
3959 Variable names are case-sensitive. The names `foo', `FOO', and
3962 It is traditional to use upper case letters in variable names, but we
3963 recommend using lower case letters for variable names that serve
3975 * Reference:: How to use the value of a variable.
3977 * Advanced:: Advanced features for referencing a variable.
3979 * Setting:: How to set a variable in the makefile.
3981 of a variable.
3982 * Override Directive:: How to set a variable in the makefile even if
3984 * Defining:: An alternate way to set a variable
3986 * Environment:: Variable values can come from the environment.
3987 * Target-specific:: Variable values can be defined on a per-target
3989 * Pattern-specific:: Target-specific variable values can be applied
3995 6.1 Basics of Variable References
3998 To substitute a variable's value, write a dollar sign followed by the
3999 name of the variable in parentheses or braces: either `$(foo)' or
4000 `${foo}' is a valid reference to the variable `foo'. This special
4004 Variable references can be used in any context: targets,
4005 prerequisites, commands, most directives, and new variable values.
4006 Here is an example of a common case, where a variable holds the names
4015 Variable references work by strict textual substitution. Thus, the
4023 variable value are ignored in variable assignments, the value of `foo'
4028 variable name. Thus, you could reference the variable `x' with `$x'.
4038 There are two ways that a variable in GNU `make' can have a value; we
4042 The first flavor of variable is a "recursively expanded" variable.
4047 references are expanded whenever this variable is substituted (in the
4062 This flavor of variable is the only sort supported by other versions
4071 cannot append something on the end of a variable, as in
4075 because it will cause an infinite loop in the variable expansion.
4080 executed every time the variable is expanded. This makes `make' run
4089 Setting Variables: Setting.). The value of a simply expanded variable
4091 variables and functions, when the variable is defined. The actual
4092 value of the simply expanded variable is the result of expanding the
4094 variables; it contains their values _as of the time this variable was
4106 When a simply expanded variable is referenced, its value is
4111 Function: Shell Function.) This example also shows use of the variable
4130 programming languages. They allow you to redefine a variable using its
4136 variable values. Leading whitespace characters are discarded from your
4137 input before substitution of variable references and function calls;
4138 this means you can include leading spaces in a variable value by
4139 protecting them with variable references, like this:
4144 Here the value of the variable `space' is precisely one space. The
4146 trailing space characters are _not_ stripped from variable values, just
4148 rather hard to read). If you put whitespace at the end of a variable
4151 whitespace characters at the end of your variable value, you must
4157 Here the value of the variable `dir' is `/foo/bar ' (with four
4162 called a conditional variable assignment operator, because it only has
4163 an effect if the variable is not yet defined. This statement:
4174 Note that a variable set to an empty value is still defined, so `?='
4175 will not set that variable.
4188 * Substitution Refs:: Referencing a variable with
4190 * Computed Names:: Computing the name of the variable to refer to.
4198 A "substitution reference" substitutes the value of a variable with
4200 `${VAR:A=B}') and its meaning is to take the value of the variable VAR,
4237 6.3.2 Computed Variable Names
4240 Computed variable names are a complicated concept needed only for
4242 consider them, except to know that making a variable with a dollar sign
4247 Variables may be referenced inside the name of a variable. This is
4248 called a "computed variable name" or a "nested variable reference".
4257 name of the variable to reference is not stated explicitly; it is
4259 within the outer variable reference.
4273 References to recursively-expanded variables within a variable name
4284 Nested variable references can also contain modified references and
4301 `$(variable2)', a simple variable reference whose value is `Hello'.
4303 A computed variable name need not consist entirely of a single
4304 variable reference. It can contain several variable references, as
4330 Computed variable names can also be used in substitution references:
4340 The only restriction on this sort of use of nested variable
4355 attempts to give `foo' the value of the variable `sort a d b g q c' or
4360 You can also use computed variable names in the left-hand side of a
4361 variable assignment, or in a `define' directive, as in:
4372 Note that "nested variable references" are quite different from
4408 To set a variable from the makefile, write a line starting with the
4409 variable name followed by `=' or `:='. Whatever follows the `=' or
4414 defines a variable named `objects'. Whitespace around the variable
4419 definitions can contain variable references which will be expanded
4423 The variable name may contain function and variable references, which
4424 are expanded when the line is read to find the actual variable name to
4427 There is no limit on the length of the value of a variable except the
4428 amount of swapping space on the computer. When a variable definition is
4434 Most variable names are considered to have the empty string as a
4442 If you'd like a variable to be set to a value only if it's not
4444 `='. These two settings of the variable `FOO' are identical (*note The
4461 Often it is useful to add more text to the value of a variable already
4466 This takes the value of the variable `objects', and adds the text
4482 When the variable in question has not been defined before, `+=' acts
4483 just like normal `=': it defines a recursively-expanded variable.
4485 depends on what flavor of variable you defined originally. *Note The
4489 When you add to a variable's value with `+=', `make' acts
4491 definition of the variable. If you defined it first with `:=', making
4492 it a simply-expanded variable, `+=' adds to that simply-expanded
4497 variable := value
4498 variable += more
4503 variable := value
4504 variable := $(variable) more
4506 On the other hand, when you use `+=' with a variable that you defined
4509 variable, `make' does not expand the value you set for variable and
4511 and saves these variable and function references to be expanded later,
4512 when you refer to the new variable (*note The Two Flavors of Variables:
4513 Flavors.). When you use `+=' on a recursively-expanded variable, it is
4516 variable = value
4517 variable += more
4522 variable = $(temp) more
4524 except that of course it never defines a variable called `temp'. The
4525 importance of this comes when the variable's old value contains
4526 variable references. Take this common example:
4532 The first line defines the `CFLAGS' variable with a reference to another
4533 variable, `includes'. (`CFLAGS' is used by the rules for C
4536 variable, meaning `$(includes) -O' is _not_ expanded when `make'
4545 `CFLAGS' as a simply-expanded variable; this means `make' expands the
4546 text `$(CFLAGS) -pg' before setting the variable. If `includes' is not
4550 reference to `includes', so if that variable gets defined at any later
4559 If a variable has been set with a command argument (*note Overriding
4561 ignored. If you want to set the variable in the makefile even though
4565 override VARIABLE = VALUE
4569 override VARIABLE := VALUE
4571 To append more text to a variable defined on the command line, use:
4573 override VARIABLE += MORE TEXT
4603 Another way to set the value of a variable is to use the `define'
4611 the variable and nothing more. The value to give the variable appears
4615 variable (*note The Two Flavors of Variables: Flavors.). The variable
4616 name may contain function and variable references, which are expanded
4617 when the directive is read to find the actual variable name to use.
4632 of the variable's value (except for the final newline which precedes
4645 If you want variable definitions made with `define' to take
4646 precedence over command-line variable definitions, you can use the
4663 run. Every environment variable that `make' sees when it starts up is
4664 transformed into a `make' variable with the same name and value.
4671 Thus, by setting the variable `CFLAGS' in your environment, you can
4693 Such problems would be especially likely with the variable `SHELL',
4697 variable in a special way; see *note Choosing the Shell::.
4702 6.10 Target-specific Variable Values
4705 Variable values in `make' are usually global; that is, they are the
4710 The other exception is "target-specific variable values". This
4711 feature allows you to define different values for the same variable,
4716 Set a target-specific variable value like this:
4718 TARGET ... : VARIABLE-ASSIGNMENT
4722 TARGET ... : override VARIABLE-ASSIGNMENT
4726 TARGET ... : export VARIABLE-ASSIGNMENT
4728 Multiple TARGET values create a target-specific variable value for
4731 The VARIABLE-ASSIGNMENT can be any valid form of assignment;
4733 (`?='). All variables that appear within the VARIABLE-ASSIGNMENT are
4735 previously-defined target-specific variable values will be in effect.
4736 Note that this variable is actually distinct from any "global" value:
4741 makefile variable. Variables provided on the command-line (and in the
4744 variable value to be preferred.
4747 you define a target-specific variable that variable value is also in
4749 prerequisites, etc. (unless those prerequisites override that variable
4750 with their own target-specific variable value). So, for example, a
4764 the same target-specific variable, then the first target to be built
4772 6.11 Pattern-specific Variable Values
4775 In addition to target-specific variable values (*note Target-specific
4776 Variable Values: Target-specific.), GNU `make' supports
4777 pattern-specific variable values. In this form, the variable is
4786 Set a pattern-specific variable value like this:
4788 PATTERN ... : VARIABLE-ASSIGNMENT
4792 PATTERN ... : override VARIABLE-ASSIGNMENT
4794 where PATTERN is a %-pattern. As with target-specific variable values,
4795 multiple PATTERN values create a pattern-specific variable value for
4796 each pattern individually. The VARIABLE-ASSIGNMENT can be any valid
4797 form of assignment. Any command-line variable setting will take
4815 value of one variable to another, or the value of a variable to a
4833 libraries if the `CC' variable is `gcc', and a different set of
4854 surrounded by parentheses. Variable substitution is performed on both
4874 When the variable `CC' has the value `gcc', the above example has
4880 When the variable `CC' has any other value, the effect is this:
4886 conditionalizing a variable assignment and then using the variable
4951 Expand all variable references in ARG1 and ARG2 and compare them.
4955 Often you want to test if a variable has a non-empty value. When
4975 Expand all variable references in ARG1 and ARG2 and compare them.
4979 `ifdef VARIABLE-NAME'
4980 The `ifdef' form takes the _name_ of a variable as its argument,
4981 not a reference to a variable. The value of that variable has a
4984 been defined have an empty value. The text VARIABLE-NAME is
4985 expanded, so it could be a variable or function that expands to
4986 the name of a variable. For example:
4994 The variable reference `$(foo)' is expanded, yielding `bar', which
4995 is considered to be the name of a variable. The variable `bar' is
4999 Note that `ifdef' only tests whether a variable has a value. It
5000 does not expand the variable to see if that value is nonempty.
5024 `ifndef VARIABLE-NAME'
5025 If the variable VARIABLE-NAME has an empty value, the TEXT-IF-TRUE
5027 The rules for expansion and testing of VARIABLE-NAME are identical
5067 `-t' by using the variable `MAKEFLAGS' together with the `findstring'
5102 the call, just as a variable might be substituted.
5112 * Value Function:: Return the un-expanded value of a variable.
5114 * Origin Function:: Find where a variable got its value.
5115 * Flavor Function:: Find out the flavor of a variable.
5125 A function call resembles a variable reference. It looks like this:
5144 themselves contain other function calls or variable references, it is
5158 argument value by variable substitution. First define variables
5271 Replacing the variable reference `$(needs_made)' with the function
5294 of strings (such as file names) in a variable. For example:
5382 Suppose that a makefile uses the `VPATH' variable to specify a list of
5396 the variable `CFLAGS', which is passed automatically to the C compiler,
5606 variable named by the expanded value of VAR is set to that word, and
5608 variable, so its expansion will be different each time.
5615 This simple example sets the variable `files' to the list of all
5632 name, with an additional variable:
5638 Here we use the variable `find_files' this way. We use plain `=' to
5639 define a recursively-expanding variable, so that its value contains an
5641 simply-expanded variable would not do, since `wildcard' would be called
5644 The `foreach' function has no permanent effect on the variable VAR;
5648 variable VAR is a simply-expanded variable during the execution of
5653 You must take care when using complex variable expressions that
5654 result in variable names because many strange things are valid variable
5659 might be useful if the value of `find_files' references the variable
5671 value of a variable, then use `call' to expand it with different values.
5675 $(call VARIABLE,PARAM,PARAM,...)
5678 temporary variables `$(1)', `$(2)', etc. The variable `$(0)' will
5679 contain VARIABLE. There is no maximum number of parameter arguments.
5683 Then VARIABLE is expanded as a `make' variable in the context of
5685 value of VARIABLE will resolve to the first PARAM in the invocation of
5688 Note that VARIABLE is the _name_ of a variable, not a _reference_ to
5689 that variable. Therefore you would not normally use a `$' or
5690 parentheses when writing it. (You can, however, use a variable
5693 If VARIABLE is the name of a builtin function, the builtin function
5694 is always invoked (even if a `make' variable by that name also exists).
5697 them to temporary variables. This means that VARIABLE values
5718 Now the variable LS contains `/bin/ls' or similar.
5747 variable _without_ having it expanded. Please note that this does not
5749 a simply expanded variable its value is expanded during the definition;
5751 the variable directly.
5755 $(value VARIABLE)
5757 Note that VARIABLE is the _name_ of a variable; not a _reference_ to
5758 that variable. Therefore you would not normally use a `$' or
5759 parentheses when writing it. (You can, however, use a variable
5763 VARIABLE, without any expansion occurring. For example, in this
5773 as a `make' variable, while the second output line would be the current
5774 value of your `$PATH' environment variable, since the `value' function
5848 a variable. Specifically, it tells you where it came from.
5852 $(origin VARIABLE)
5854 Note that VARIABLE is the _name_ of a variable to inquire about; not
5855 a _reference_ to that variable. Therefore you would not normally use a
5856 `$' or parentheses when writing it. (You can, however, use a variable
5859 The result of this function is a string telling you how the variable
5860 VARIABLE was defined:
5863 if VARIABLE was never defined.
5866 if VARIABLE has a default definition, as is usual with `CC' and so
5868 Note that if you have redefined a default variable, the `origin'
5872 if VARIABLE was defined as an environment variable and the `-e'
5877 if VARIABLE was defined as an environment variable and the `-e'
5881 if VARIABLE was defined in a makefile.
5884 if VARIABLE was defined on the command line.
5887 if VARIABLE was defined with an `override' directive in a makefile
5891 if VARIABLE is an automatic variable defined for the execution of
5895 to determine if you want to believe the value of a variable. For
5897 makefile `bar'. You want a variable `bletch' to be defined in `bar' if
5934 tells you something _about_ a variable. Specifically, it tells you the
5935 flavor of a variable (*note The Two Flavors of Variables: Flavors.).
5939 $(flavor VARIABLE)
5941 Note that VARIABLE is the _name_ of a variable to inquire about; not
5942 a _reference_ to that variable. Therefore you would not normally use a
5943 `$' or parentheses when writing it. (You can, however, use a variable
5947 of the variable VARIABLE:
5950 if VARIABLE was never defined.
5953 if VARIABLE is a recursively expanded variable.
5956 if VARIABLE is a simply expanded variable.
6011 recursive variable assignment, it won't be evaluated until later.
6021 `make' variable `ERROR1' is defined. Or,
6086 * Overriding:: How to override a variable to specify
6127 variable (*note Other Special Variables: Special Variables.).
6136 a switch or variable definition, respectively). Even targets not in
6140 `Make' will set the special variable `MAKECMDGOALS' to the list of
6142 command line, this variable is empty. Note that this variable should
6290 or contain `$(MAKE)' or `${MAKE}' (*Note How the `MAKE' Variable Works:
6291 MAKE Variable.)
6355 An argument that contains `=' specifies the value of a variable: `V=X'
6356 sets the value of the variable V to X. If you specify a value in this
6357 way, all ordinary assignments of the same variable in the makefile are
6362 compilers. For example, in a properly written makefile, the variable
6378 the value of a variable when you override it.)
6380 The variable `CFLAGS' is only one of many standard variables that
6388 When you override a variable with a command argument, you can define
6389 either a recursively-expanded variable or a simply-expanded variable.
6390 The examples shown above make a recursively-expanded variable; to make a
6391 simply-expanded variable, write `:=' instead of `='. But, unless you
6392 want to include a variable reference or function call in the _value_
6393 that you specify, it makes no difference which kind of variable you
6396 There is one way that the makefile can change a variable that you
6398 line that looks like this: `override VARIABLE = VALUE' (*note The
6592 Print the data base (rules and variable values) that results from
6599 command and variable definitions, so it can be a useful debugging
6689 undefined variable. This can be helpful when you are trying to
6715 way the implicit rule works. For example, the variable `CFLAGS'
7011 file uses the variable `COMPILE.X'. Similarly, the rule to produce an
7015 Every rule that produces an object file uses the variable
7016 `OUTPUT_OPTION'. `make' defines this variable either to contain `-o
7053 executable program name.) If a variable value contains more than one
