This is Info file make.info, produced by Makeinfo-1.54 from the input
file ./make.texinfo.
   This file documents the GNU Make utility, which determines
automatically which pieces of a large program need to be recompiled,
and issues the commands to recompile them.
   This is Edition 0.45, last updated 11 May 1994, of `The GNU Make
Manual', for `make', Version 3.71 Beta.
   Copyright (C) 1988, '89, '90, '91, '92, '93, '94 Free Software
Foundation, Inc.
   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Free Software Foundation.
File: make.info,  Node: Concept Index,  Next: Name Index,  Prev: Complex Makefile,  Up: Top
Index of Concepts
*****************
* Menu:
* +, and define:                        Sequences.
* +=:                                   Appending.
* ,v (RCS file extension):              Catalogue of Rules.
* -, and define:                        Sequences.
* .c:                                   Catalogue of Rules.
* .C:                                   Catalogue of Rules.
* .cc:                                  Catalogue of Rules.
* .ch:                                  Catalogue of Rules.
* .def:                                 Catalogue of Rules.
* .dvi:                                 Catalogue of Rules.
* .F:                                   Catalogue of Rules.
* .f:                                   Catalogue of Rules.
* .info:                                Catalogue of Rules.
* .l:                                   Catalogue of Rules.
* .ln:                                  Catalogue of Rules.
* .mod:                                 Catalogue of Rules.
* .o:                                   Catalogue of Rules.
* .o:                                   Catalogue of Rules.
* .p:                                   Catalogue of Rules.
* .r:                                   Catalogue of Rules.
* .S:                                   Catalogue of Rules.
* .s:                                   Catalogue of Rules.
* .sh:                                  Catalogue of Rules.
* .sym:                                 Catalogue of Rules.
* .tex:                                 Catalogue of Rules.
* .texi:                                Catalogue of Rules.
* .texinfo:                             Catalogue of Rules.
* .txinfo:                              Catalogue of Rules.
* .w:                                   Catalogue of Rules.
* .web:                                 Catalogue of Rules.
* .y:                                   Catalogue of Rules.
* :=:                                   Setting.
* :=:                                   Flavors.
* =:                                    Setting.
* =:                                    Flavors.
* @, and define:                        Sequences.
* #include:                             Automatic Dependencies.
* # (comments), in commands:            Commands.
* # (comments), in makefile:            Makefile Contents.
* $, in function call:                  Syntax of Functions.
* $, in rules:                          Rule Syntax.
* $, in variable name:                  Computed Names.
* $, in variable reference:             Reference.
* %, in pattern rules:                  Pattern Intro.
* %, quoting in patsubst:               Text Functions.
* %, quoting in vpath:                  Selective Search.
* %, quoting in static pattern:         Static Usage.
* %, quoting with \ (backslash):        Static Usage.
* %, quoting with \ (backslash):        Selective Search.
* %, quoting with \ (backslash):        Text Functions.
* * (wildcard character):               Wildcards.
* -assume-new:                          Instead of Execution.
* -assume-new:                          Options Summary.
* -assume-new, and recursion:           Options/Recursion.
* -assume-old:                          Options Summary.
* -assume-old:                          Avoiding Compilation.
* -assume-old, and recursion:           Options/Recursion.
* -debug:                               Options Summary.
* -directory:                           Options Summary.
* -directory:                           Recursion.
* -directory, and -print-directory:     -w Option.
* -directory, and recursion:            Options/Recursion.
* -dry-run:                             Instead of Execution.
* -dry-run:                             Options Summary.
* -dry-run:                             Echoing.
* -environment-overrides:               Options Summary.
* -file:                                Options Summary.
* -file:                                Makefile Names.
* -file:                                Makefile Arguments.
* -file, and recursion:                 Options/Recursion.
* -help:                                Options Summary.
* -ignore-errors:                       Options Summary.
* -ignore-errors:                       Errors.
* -include-dir:                         Options Summary.
* -include-dir:                         Include.
* -include-dir, and recursion:          Options/Recursion.
* -jobs:                                Options Summary.
* -jobs:                                Parallel.
* -jobs, and recursion:                 Options/Recursion.
* -just-print:                          Options Summary.
* -just-print:                          Instead of Execution.
* -just-print:                          Echoing.
* -keep-going:                          Errors.
* -keep-going:                          Testing.
* -keep-going:                          Options Summary.
* -load-average:                        Parallel.
* -load-average:                        Options Summary.
* -makefile:                            Makefile Arguments.
* -makefile:                            Makefile Names.
* -makefile:                            Options Summary.
* -max-load:                            Options Summary.
* -max-load:                            Parallel.
* -new-file:                            Options Summary.
* -new-file:                            Instead of Execution.
* -new-file, and recursion:             Options/Recursion.
* -no-builtin-rules:                    Options Summary.
* -no-keep-going:                       Options Summary.
* -no-print-directory:                  Options Summary.
* -no-print-directory:                  -w Option.
* -old-file:                            Avoiding Compilation.
* -old-file:                            Options Summary.
* -old-file, and recursion:             Options/Recursion.
* -print-data-base:                     Options Summary.
* -print-directory:                     Options Summary.
* -print-directory, and -directory:     -w Option.
* -print-directory, and recursion:      -w Option.
* -print-directory, disabling:          -w Option.
* -question:                            Options Summary.
* -question:                            Instead of Execution.
* -quiet:                               Echoing.
* -quiet:                               Options Summary.
* -recon:                               Instead of Execution.
* -recon:                               Echoing.
* -recon:                               Options Summary.
* -silent:                              Echoing.
* -silent:                              Options Summary.
* -stop:                                Options Summary.
* -touch:                               Instead of Execution.
* -touch:                               Options Summary.
* -touch, and recursion:                MAKE Variable.
* -version:                             Options Summary.
* -warn-undefined-variables:            Options Summary.
* -what-if:                             Instead of Execution.
* -what-if:                             Options Summary.
* -b:                                   Options Summary.
* -C:                                   Options Summary.
* -C:                                   Recursion.
* -C, and -w:                           -w Option.
* -C, and recursion:                    Options/Recursion.
* -d:                                   Options Summary.
* -e:                                   Options Summary.
* -e (shell flag):                      Automatic Dependencies.
* -f:                                   Makefile Names.
* -f:                                   Options Summary.
* -f:                                   Makefile Arguments.
* -f, and recursion:                    Options/Recursion.
* -h:                                   Options Summary.
* -i:                                   Options Summary.
* -i:                                   Errors.
* -I:                                   Options Summary.
* -I:                                   Include.
* -I, and recursion:                    Options/Recursion.
* -j:                                   Parallel.
* -j:                                   Options Summary.
* -j, and recursion:                    Options/Recursion.
* -k:                                   Errors.
* -k:                                   Testing.
* -k:                                   Options Summary.
* -l:                                   Options Summary.
* -l (library search):                  Libraries/Search.
* -l (load average):                    Parallel.
* -m:                                   Options Summary.
* -M (to compiler):                     Automatic Dependencies.
* -n:                                   Options Summary.
* -n:                                   Instead of Execution.
* -n:                                   Echoing.
* -o:                                   Avoiding Compilation.
* -o:                                   Options Summary.
* -o, and recursion:                    Options/Recursion.
* -p:                                   Options Summary.
* -q:                                   Instead of Execution.
* -q:                                   Options Summary.
* -r:                                   Options Summary.
* -S:                                   Options Summary.
* -s:                                   Echoing.
* -s:                                   Options Summary.
* -t:                                   Instead of Execution.
* -t:                                   Options Summary.
* -t, and recursion:                    MAKE Variable.
* -v:                                   Options Summary.
* -w:                                   Options Summary.
* -W:                                   Options Summary.
* -W:                                   Instead of Execution.
* -w, and -C:                           -w Option.
* -W, and recursion:                    Options/Recursion.
* -w, and recursion:                    -w Option.
* -w, disabling:                        -w Option.
* - (in commands):                      Errors.
* .a (archives):                        Archive Suffix Rules.
* .d:                                   Automatic Dependencies.
* .PRECIOUS intermediate files:         Chained Rules.
* :: rules (double-colon):              Double-Colon.
* ? (wildcard character):               Wildcards.
* @ (in commands):                      Echoing.
* all (standard target):                Goals.
* cd (shell command):                   Execution.
* cd (shell command):                   MAKE Variable.
* check (standard target):              Goals.
* clean (standard target):              Goals.
* clean target:                         Cleanup.
* clean target:                         Simple Makefile.
* clobber (standard target):            Goals.
* distclean (standard target):          Goals.
* dist (standard target):               Goals.
* FORCE:                                Force Targets.
* install (standard target):            Goals.
* lint, rule to run:                    Catalogue of Rules.
* lpr (shell command):                  Wildcard Examples.
* lpr (shell command):                  Empty Targets.
* make depend:                          Automatic Dependencies.
* mostlyclean (standard target):        Goals.
* OBJECTS:                              Variables Simplify.
* objects:                              Variables Simplify.
* OBJS:                                 Variables Simplify.
* objs:                                 Variables Simplify.
* OBJ:                                  Variables Simplify.
* obj:                                  Variables Simplify.
* print (standard target):              Goals.
* print target:                         Wildcard Examples.
* print target:                         Empty Targets.
* README:                               Makefile Names.
* realclean (standard target):          Goals.
* rm (shell command):                   Phony Targets.
* rm (shell command):                   Wildcard Examples.
* rm (shell command):                   Errors.
* rm (shell command):                   Simple Makefile.
* sed (shell command):                  Automatic Dependencies.
* shar (standard target):               Goals.
* TAGS (standard target):               Goals.
* tar (standard target):                Goals.
* test (standard target):               Goals.
* touch (shell command):                Wildcard Examples.
* touch (shell command):                Empty Targets.
* VPATH, and implicit rules:            Implicit/Search.
* VPATH, and link libraries:            Libraries/Search.
* yacc:                                 Sequences.
* [...] (wildcard characters):          Wildcards.
* \ (backslash), for continuation lines: Simple Makefile.
* \ (backslash), in commands:           Execution.
* \ (backslash), to quote %:            Static Usage.
* \ (backslash), to quote %:            Text Functions.
* \ (backslash), to quote %:            Selective Search.
* __.SYMDEF:                            Archive Symbols.
* ~ (tilde):                            Wildcards.
* TeX, rule to run:                     Catalogue of Rules.
* appending to variables:               Appending.
* ar:                                   Implicit Variables.
* archive:                              Archives.
* archive member targets:               Archive Members.
* archive symbol directory updating:    Archive Symbols.
* archive, suffix rule for:             Archive Suffix Rules.
* arguments of functions:               Syntax of Functions.
* as:                                   Catalogue of Rules.
* as:                                   Implicit Variables.
* assembly, rule to compile:            Catalogue of Rules.
* automatic generation of dependencies: Automatic Dependencies.
* automatic generation of dependencies: Include.
* automatic variables:                  Automatic.
* backquotes:                           Shell Function.
* backslash (\), for continuation lines: Simple Makefile.
* backslash (\), in commands:           Execution.
* backslash (\), to quote %:            Static Usage.
* backslash (\), to quote %:            Selective Search.
* backslash (\), to quote %:            Text Functions.
* basename:                             Filename Functions.
* broken pipe:                          Parallel.
* bugs, reporting:                      Bugs.
* built-in special targets:             Special Targets.
* C++, rule to compile:                 Catalogue of Rules.
* C, rule to compile:                   Catalogue of Rules.
* cc:                                   Implicit Variables.
* cc:                                   Catalogue of Rules.
* chains of rules:                      Chained Rules.
* cleaning up:                          Cleanup.
* co:                                   Implicit Variables.
* co:                                   Catalogue of Rules.
* combining rules by dependency:        Combine By Dependency.
* command line variables:               Overriding.
* commands:                             Rule Syntax.
* commands, backslash (\) in:           Execution.
* commands, comments in:                Commands.
* commands, echoing:                    Echoing.
* commands, empty:                      Empty Commands.
* commands, errors in:                  Errors.
* commands, execution:                  Execution.
* commands, execution in parallel:      Parallel.
* commands, expansion:                  Shell Function.
* commands, how to write:               Commands.
* commands, instead of executing:       Instead of Execution.
* commands, introduction to:            Rule Introduction.
* commands, quoting newlines in:        Execution.
* commands, sequences of:               Sequences.
* comments, in commands:                Commands.
* comments, in makefile:                Makefile Contents.
* compatibility:                        Features.
* compatibility in exporting:           Variables/Recursion.
* compilation, testing:                 Testing.
* computed variable name:               Computed Names.
* conditionals:                         Conditionals.
* continuation lines:                   Simple Makefile.
* conventions for makefiles:            Makefile Conventions.
* ctangle:                              Implicit Variables.
* ctangle:                              Catalogue of Rules.
* cweave:                               Implicit Variables.
* cweave:                               Catalogue of Rules.
* deducing commands (implicit rules):   make Deduces.
* default goal:                         How Make Works.
* default goal:                         Rules.
* default makefile name:                Makefile Names.
* default rules, last-resort:           Last Resort.
* defining variables verbatim:          Defining.
* deletion of target files:             Interrupts.
* dependencies:                         Rule Syntax.
* dependencies, automatic generation:   Automatic Dependencies.
* dependencies, automatic generation:   Include.
* dependencies, introduction to:        Rule Introduction.
* dependencies, list of all:            Automatic.
* dependencies, list of changed:        Automatic.
* dependencies, varying (static pattern): Static Pattern.
* dependency:                           Rules.
* dependency pattern, implicit:         Pattern Intro.
* dependency pattern, static (not implicit): Static Usage.
* directive:                            Makefile Contents.
* directories, printing them:           -w Option.
* directories, updating archive symbol: Archive Symbols.
* directory part:                       Filename Functions.
* directory search (VPATH):             Directory Search.
* directory search (VPATH), and implicit rules: Implicit/Search.
* directory search (VPATH), and link libraries: Libraries/Search.
* directory search (VPATH), and shell commands: Commands/Search.
* dollar sign ($), in function call:    Syntax of Functions.
* dollar sign ($), in rules:            Rule Syntax.
* dollar sign ($), in variable name:    Computed Names.
* dollar sign ($), in variable reference: Reference.
* double-colon rules:                   Double-Colon.
* duplicate words, removing:            Text Functions.
* echoing of commands:                  Echoing.
* editor:                               Introduction.
* Emacs (M-x compile):                  Errors.
* empty commands:                       Empty Commands.
* empty targets:                        Empty Targets.
* environment:                          Environment.
* environment, SHELL in:                Execution.
* environment, and recursion:           Variables/Recursion.
* errors (in commands):                 Errors.
* errors with wildcards:                Wildcard Pitfall.
* execution, in parallel:               Parallel.
* execution, instead of:                Instead of Execution.
* execution, of commands:               Execution.
* exit status (errors):                 Errors.
* explicit rule, definition of:         Makefile Contents.
* exporting variables:                  Variables/Recursion.
* f77:                                  Implicit Variables.
* f77:                                  Catalogue of Rules.
* features of GNU make:                 Features.
* features, missing:                    Missing.
* file name functions:                  Filename Functions.
* file name of makefile:                Makefile Names.
* file name of makefile, how to specify: Makefile Names.
* file name prefix, adding:             Filename Functions.
* file name suffix:                     Filename Functions.
* file name suffix, adding:             Filename Functions.
* file name with wildcards:             Wildcards.
* file name, basename of:               Filename Functions.
* file name, directory part:            Filename Functions.
* file name, nondirectory part:         Filename Functions.
* files, assuming new:                  Instead of Execution.
* files, assuming old:                  Avoiding Compilation.
* files, avoiding recompilation of:     Avoiding Compilation.
* files, intermediate:                  Chained Rules.
* filtering out words:                  Text Functions.
* filtering words:                      Text Functions.
* finding strings:                      Text Functions.
* flags:                                Options Summary.
* flags for compilers:                  Implicit Variables.
* flavors of variables:                 Flavors.
* force targets:                        Force Targets.
* Fortran, rule to compile:             Catalogue of Rules.
* functions:                            Functions.
* functions, for file names:            Filename Functions.
* functions, for text:                  Text Functions.
* functions, syntax of:                 Syntax of Functions.
* g++:                                  Catalogue of Rules.
* g++:                                  Implicit Variables.
* gcc:                                  Catalogue of Rules.
* generating dependencies automatically: Automatic Dependencies.
* generating dependencies automatically: Include.
* get:                                  Implicit Variables.
* get:                                  Catalogue of Rules.
* globbing (wildcards):                 Wildcards.
* goal:                                 How Make Works.
* goal, default:                        How Make Works.
* goal, default:                        Rules.
* goal, how to specify:                 Goals.
* home directory:                       Wildcards.
* IEEE Standard 1003.2:                 Overview.
* implicit rule:                        Implicit Rules.
* implicit rule, and VPATH:             Implicit/Search.
* implicit rule, and directory search:  Implicit/Search.
* implicit rule, definition of:         Makefile Contents.
* implicit rule, how to use:            Using Implicit.
* implicit rule, introduction to:       make Deduces.
* implicit rule, predefined:            Catalogue of Rules.
* implicit rule, search algorithm:      Search Algorithm.
* including (MAKEFILES variable):       MAKEFILES Variable.
* including other makefiles:            Include.
* incompatibilities:                    Missing.
* Info, rule to format:                 Catalogue of Rules.
* intermediate files:                   Chained Rules.
* intermediate files, preserving:       Chained Rules.
* interrupt:                            Interrupts.
* job slots:                            Parallel.
* job slots, and recursion:             Options/Recursion.
* jobs, limiting based on load:         Parallel.
* joining lists of words:               Filename Functions.
* killing (interruption):               Interrupts.
* last-resort default rules:            Last Resort.
* ld:                                   Catalogue of Rules.
* lex:                                  Implicit Variables.
* lex:                                  Catalogue of Rules.
* Lex, rule to run:                     Catalogue of Rules.
* libraries for linking, directory search: Libraries/Search.
* library archive, suffix rule for:     Archive Suffix Rules.
* limiting jobs based on load:          Parallel.
* link libraries, and directory search: Libraries/Search.
* linking, predefined rule for:         Catalogue of Rules.
* lint:                                 Catalogue of Rules.
* list of all dependencies:             Automatic.
* list of changed dependencies:         Automatic.
* load average:                         Parallel.
* loops in variable expansion:          Flavors.
* m2c:                                  Catalogue of Rules.
* macro:                                Using Variables.
* makefile:                             Introduction.
* makefile name:                        Makefile Names.
* makefile name, how to specify:        Makefile Names.
* makefile rule parts:                  Rule Introduction.
* makefile, and MAKEFILES variable:     MAKEFILES Variable.
* makefile, conventions for:            Makefile Conventions.
* makefile, how make processes:         How Make Works.
* makefile, how to write:               Makefiles.
* makefile, including:                  Include.
* makefile, overriding:                 Overriding Makefiles.
* makefile, remaking of:                Remaking Makefiles.
* makefile, simple:                     Simple Makefile.
* makeinfo:                             Implicit Variables.
* makeinfo:                             Catalogue of Rules.
* match-anything rule:                  Match-Anything Rules.
* match-anything rule, used to override: Overriding Makefiles.
* missing features:                     Missing.
* mistakes with wildcards:              Wildcard Pitfall.
* modified variable reference:          Substitution Refs.
* Modula-2, rule to compile:            Catalogue of Rules.
* multiple rules for one target:        Multiple Rules.
* multiple rules for one target (::):   Double-Colon.
* multiple targets:                     Multiple Targets.
* multiple targets, in pattern rule:    Pattern Intro.
* name of makefile:                     Makefile Names.
* name of makefile, how to specify:     Makefile Names.
* nested variable reference:            Computed Names.
* newline, quoting, in commands:        Execution.
* newline, quoting, in makefile:        Simple Makefile.
* nondirectory part:                    Filename Functions.
* old-fashioned suffix rules:           Suffix Rules.
* options:                              Options Summary.
* options, and recursion:               Options/Recursion.
* options, setting from environment:    Options/Recursion.
* options, setting in makefiles:        Options/Recursion.
* order of pattern rules:               Pattern Intro.
* origin of variable:                   Origin Function.
* overriding makefiles:                 Overriding Makefiles.
* overriding variables with arguments:  Overriding.
* overriding with override:             Override Directive.
* parallel execution:                   Parallel.
* parts of makefile rule:               Rule Introduction.
* Pascal, rule to compile:              Catalogue of Rules.
* pattern rule:                         Pattern Intro.
* pattern rules, order of:              Pattern Intro.
* pattern rules, static (not implicit): Static Pattern.
* pattern rules, static, syntax of:     Static Usage.
* pc:                                   Catalogue of Rules.
* pc:                                   Implicit Variables.
* phony targets:                        Phony Targets.
* pitfalls of wildcards:                Wildcard Pitfall.
* portability:                          Features.
* POSIX:                                Overview.
* precious targets:                     Special Targets.
* prefix, adding:                       Filename Functions.
* preserving intermediate files:        Chained Rules.
* preserving with .PRECIOUS:            Chained Rules.
* preserving with .PRECIOUS:            Special Targets.
* printing directories:                 -w Option.
* printing of commands:                 Echoing.
* problems and bugs, reporting:         Bugs.
* problems with wildcards:              Wildcard Pitfall.
* processing a makefile:                How Make Works.
* question mode:                        Instead of Execution.
* quoting %, in patsubst:               Text Functions.
* quoting %, in vpath:                  Selective Search.
* quoting %, in static pattern:         Static Usage.
* quoting newline, in commands:         Execution.
* quoting newline, in makefile:         Simple Makefile.
* Ratfor, rule to compile:              Catalogue of Rules.
* RCS, rule to extract from:            Catalogue of Rules.
* recompilation:                        Introduction.
* recompilation, avoiding:              Avoiding Compilation.
* recording events with empty targets:  Empty Targets.
* recursion:                            Recursion.
* recursion, and -C:                    Options/Recursion.
* recursion, and -f:                    Options/Recursion.
* recursion, and -I:                    Options/Recursion.
* recursion, and -j:                    Options/Recursion.
* recursion, and -o:                    Options/Recursion.
* recursion, and -t:                    MAKE Variable.
* recursion, and -W:                    Options/Recursion.
* recursion, and -w:                    -w Option.
* recursion, and MAKEFILES variable:    MAKEFILES Variable.
* recursion, and MAKE variable:         MAKE Variable.
* recursion, and environment:           Variables/Recursion.
* recursion, and options:               Options/Recursion.
* recursion, and printing directories:  -w Option.
* recursion, and variables:             Variables/Recursion.
* recursion, level of:                  Variables/Recursion.
* recursive variable expansion:         Flavors.
* recursive variable expansion:         Using Variables.
* recursively expanded variables:       Flavors.
* reference to variables:               Reference.
* reference to variables:               Advanced.
* relinking:                            How Make Works.
* remaking makefiles:                   Remaking Makefiles.
* removing duplicate words:             Text Functions.
* removing, to clean up:                Cleanup.
* reporting bugs:                       Bugs.
* rm:                                   Implicit Variables.
* rule commands:                        Commands.
* rule dependencies:                    Rule Syntax.
* rule syntax:                          Rule Syntax.
* rule targets:                         Rule Syntax.
* rule, and $:                          Rule Syntax.
* rule, double-colon (::):              Double-Colon.
* rule, explicit, definition of:        Makefile Contents.
* rule, how to write:                   Rules.
* rule, implicit:                       Implicit Rules.
* rule, implicit, and VPATH:            Implicit/Search.
* rule, implicit, and directory search: Implicit/Search.
* rule, implicit, chains of:            Chained Rules.
* rule, implicit, definition of:        Makefile Contents.
* rule, implicit, how to use:           Using Implicit.
* rule, implicit, introduction to:      make Deduces.
* rule, implicit, predefined:           Catalogue of Rules.
* rule, introduction to:                Rule Introduction.
* rule, multiple for one target:        Multiple Rules.
* rule, no commands or dependencies:    Force Targets.
* rule, pattern:                        Pattern Intro.
* rule, static pattern:                 Static Pattern.
* rule, static pattern versus implicit: Static versus Implicit.
* rule, with multiple targets:          Multiple Targets.
* s. (SCCS file prefix):                Catalogue of Rules.
* SCCS, rule to extract from:           Catalogue of Rules.
* search algorithm, implicit rule:      Search Algorithm.
* search path for dependencies (VPATH): Directory Search.
* search path for dependencies (VPATH), and implicit rules: Implicit/Search.
* search path for dependencies (VPATH), and link libraries: Libraries/Search.
* searching for strings:                Text Functions.
* selecting words:                      Filename Functions.
* sequences of commands:                Sequences.
* setting options from environment:     Options/Recursion.
* setting options in makefiles:         Options/Recursion.
* setting variables:                    Setting.
* several rules for one target:         Multiple Rules.
* several targets in a rule:            Multiple Targets.
* shell command:                        Simple Makefile.
* shell command, and directory search:  Commands/Search.
* shell command, execution:             Execution.
* shell command, function for:          Shell Function.
* shell file name pattern (in include): Include.
* shell wildcards (in include):         Include.
* signal:                               Interrupts.
* silent operation:                     Echoing.
* simple makefile:                      Simple Makefile.
* simple variable expansion:            Using Variables.
* simplifying with variables:           Variables Simplify.
* simply expanded variables:            Flavors.
* sorting words:                        Text Functions.
* spaces, in variable values:           Flavors.
* spaces, stripping:                    Text Functions.
* special targets:                      Special Targets.
* specifying makefile name:             Makefile Names.
* standard input:                       Parallel.
* standards conformance:                Overview.
* standards for makefiles:              Makefile Conventions.
* static pattern rule:                  Static Pattern.
* static pattern rule, syntax of:       Static Usage.
* static pattern rule, versus implicit: Static versus Implicit.
* stem:                                 Pattern Match.
* stem:                                 Static Usage.
* stem, variable for:                   Automatic.
* strings, searching for:               Text Functions.
* stripping whitespace:                 Text Functions.
* sub-make:                             Variables/Recursion.
* subdirectories, recursion for:        Recursion.
* substitution variable reference:      Substitution Refs.
* suffix rule:                          Suffix Rules.
* suffix rule, for archive:             Archive Suffix Rules.
* suffix, adding:                       Filename Functions.
* suffix, function to find:             Filename Functions.
* suffix, substituting in variables:    Substitution Refs.
* switches:                             Options Summary.
* symbol directories, updating archive: Archive Symbols.
* syntax of rules:                      Rule Syntax.
* tab character (in commands):          Rule Syntax.
* tabs in rules:                        Rule Introduction.
* tangle:                               Implicit Variables.
* tangle:                               Catalogue of Rules.
* target:                               Rules.
* target pattern, implicit:             Pattern Intro.
* target pattern, static (not implicit): Static Usage.
* target, deleting on interrupt:        Interrupts.
* target, multiple in pattern rule:     Pattern Intro.
* target, multiple rules for one:       Multiple Rules.
* target, touching:                     Instead of Execution.
* targets:                              Rule Syntax.
* targets without a file:               Phony Targets.
* targets, built-in special:            Special Targets.
* targets, empty:                       Empty Targets.
* targets, force:                       Force Targets.
* targets, introduction to:             Rule Introduction.
* targets, multiple:                    Multiple Targets.
* targets, phony:                       Phony Targets.
* terminal rule:                        Match-Anything Rules.
* testing compilation:                  Testing.
* tex:                                  Implicit Variables.
* tex:                                  Catalogue of Rules.
* texi2dvi:                             Implicit Variables.
* texi2dvi:                             Catalogue of Rules.
* Texinfo, rule to format:              Catalogue of Rules.
* tilde (~):                            Wildcards.
* touching files:                       Instead of Execution.
* undefined variables, warning message: Options Summary.
* updating archive symbol directories:  Archive Symbols.
* updating makefiles:                   Remaking Makefiles.
* value:                                Using Variables.
* value, how a variable gets it:        Values.
* variable:                             Using Variables.
* variable definition:                  Makefile Contents.
* variables:                            Variables Simplify.
* variables, $ in name:                 Computed Names.
* variables, and implicit rule:         Automatic.
* variables, appending to:              Appending.
* variables, automatic:                 Automatic.
* variables, command line:              Overriding.
* variables, computed names:            Computed Names.
* variables, defining verbatim:         Defining.
* variables, environment:               Environment.
* variables, environment:               Variables/Recursion.
* variables, exporting:                 Variables/Recursion.
* variables, flavors:                   Flavors.
* variables, how they get their values: Values.
* variables, how to reference:          Reference.
* variables, loops in expansion:        Flavors.
* variables, modified reference:        Substitution Refs.
* variables, nested references:         Computed Names.
* variables, origin of:                 Origin Function.
* variables, overriding:                Override Directive.
* variables, overriding with arguments: Overriding.
* variables, recursively expanded:      Flavors.
* variables, setting:                   Setting.
* variables, simply expanded:           Flavors.
* variables, spaces in values:          Flavors.
* variables, substituting suffix in:    Substitution Refs.
* variables, substitution reference:    Substitution Refs.
* variables, warning for undefined:     Options Summary.
* varying dependencies:                 Static Pattern.
* verbatim variable definition:         Defining.
* vpath:                                Directory Search.
* weave:                                Catalogue of Rules.
* weave:                                Implicit Variables.
* Web, rule to run:                     Catalogue of Rules.
* what if:                              Instead of Execution.
* whitespace, in variable values:       Flavors.
* whitespace, stripping:                Text Functions.
* wildcard:                             Wildcards.
* wildcard pitfalls:                    Wildcard Pitfall.
* wildcard, function:                   Filename Functions.
* wildcard, in include:                 Include.
* wildcard, in archive member:          Archive Members.
* words, extracting first:              Filename Functions.
* words, filtering:                     Text Functions.
* words, filtering out:                 Text Functions.
* words, finding number:                Filename Functions.
* words, iterating over:                Foreach Function.
* words, joining lists:                 Filename Functions.
* words, removing duplicates:           Text Functions.
* words, selecting:                     Filename Functions.
* writing rule commands:                Commands.
* writing rules:                        Rules.
* yacc:                                 Catalogue of Rules.
* yacc:                                 Implicit Variables.
* Yacc, rule to run:                    Catalogue of Rules.
File: make.info,  Node: Name Index,  Prev: Concept Index,  Up: Top
Index of Functions, Variables, & Directives
*******************************************
* Menu:
* $%:                                   Automatic.
* $(%D):                                Automatic.
* $(%F):                                Automatic.
* $(*D):                                Automatic.
* $(*F):                                Automatic.
* $(<D):                                Automatic.
* $(<F):                                Automatic.
* $(?D):                                Automatic.
* $(?F):                                Automatic.
* $(@D):                                Automatic.
* $(@F):                                Automatic.
* $(^D):                                Automatic.
* $(^F):                                Automatic.
* $*:                                   Automatic.
* $*, and static pattern:               Static Usage.
* $<:                                   Automatic.
* $?:                                   Automatic.
* $@:                                   Automatic.
* $^:                                   Automatic.
* % (automatic variable):               Automatic.
* %D (automatic variable):              Automatic.
* %F (automatic variable):              Automatic.
* * (automatic variable), unsupported bizarre usage: Missing.
* * (automatic variable):               Automatic.
* *D (automatic variable):              Automatic.
* *F (automatic variable):              Automatic.
* .DEFAULT:                             Special Targets.
* .DEFAULT:                             Last Resort.
* .DEFAULT, and empty commands:         Empty Commands.
* .EXPORT_ALL_VARIABLES:                Variables/Recursion.
* .EXPORT_ALL_VARIABLES:                Special Targets.
* .IGNORE:                              Special Targets.
* .IGNORE:                              Errors.
* .PHONY:                               Special Targets.
* .PHONY:                               Phony Targets.
* .PRECIOUS:                            Interrupts.
* .PRECIOUS:                            Special Targets.
* .SILENT:                              Echoing.
* .SILENT:                              Special Targets.
* .SUFFIXES:                            Special Targets.
* .SUFFIXES:                            Suffix Rules.
* /usr/gnu/include:                     Include.
* /usr/include:                         Include.
* /usr/local/include:                   Include.
* < (automatic variable):               Automatic.
* <D (automatic variable):              Automatic.
* <F (automatic variable):              Automatic.
* ? (automatic variable):               Automatic.
* ?D (automatic variable):              Automatic.
* ?F (automatic variable):              Automatic.
* @ (automatic variable):               Automatic.
* @D (automatic variable):              Automatic.
* @F (automatic variable):              Automatic.
* addprefix:                            Filename Functions.
* addsuffix:                            Filename Functions.
* AR:                                   Implicit Variables.
* ARFLAGS:                              Implicit Variables.
* AS:                                   Implicit Variables.
* ASFLAGS:                              Implicit Variables.
* basename:                             Filename Functions.
* CC:                                   Implicit Variables.
* CFLAGS:                               Implicit Variables.
* CO:                                   Implicit Variables.
* COFLAGS:                              Implicit Variables.
* CPP:                                  Implicit Variables.
* CPPFLAGS:                             Implicit Variables.
* CTANGLE:                              Implicit Variables.
* CWEAVE:                               Implicit Variables.
* CXX:                                  Implicit Variables.
* CXXFLAGS:                             Implicit Variables.
* define:                               Defining.
* dir:                                  Filename Functions.
* else:                                 Conditional Syntax.
* endef:                                Defining.
* endif:                                Conditional Syntax.
* export:                               Variables/Recursion.
* FC:                                   Implicit Variables.
* FFLAGS:                               Implicit Variables.
* filter:                               Text Functions.
* filter-out:                           Text Functions.
* findstring:                           Text Functions.
* firstword:                            Filename Functions.
* foreach:                              Foreach Function.
* GET:                                  Implicit Variables.
* GFLAGS:                               Implicit Variables.
* GNUmakefile:                          Makefile Names.
* ifdef:                                Conditional Syntax.
* ifeq:                                 Conditional Syntax.
* ifndef:                               Conditional Syntax.
* ifneq:                                Conditional Syntax.
* include:                              Include.
* join:                                 Filename Functions.
* LDFLAGS:                              Implicit Variables.
* LEX:                                  Implicit Variables.
* LFLAGS:                               Implicit Variables.
* MAKE:                                 MAKE Variable.
* MAKE:                                 Flavors.
* Makefile:                             Makefile Names.
* makefile:                             Makefile Names.
* MAKEFILES:                            Variables/Recursion.
* MAKEFILES:                            MAKEFILES Variable.
* MAKEFLAGS:                            Options/Recursion.
* MAKEINFO:                             Implicit Variables.
* MAKELEVEL:                            Variables/Recursion.
* MAKELEVEL:                            Flavors.
* MAKEOVERRIDES:                        MAKE Variable.
* MAKE_COMMAND:                         MAKE Variable.
* MFLAGS:                               Options/Recursion.
* notdir:                               Filename Functions.
* origin:                               Origin Function.
* OUTPUT_OPTION:                        Catalogue of Rules.
* override:                             Override Directive.
* patsubst:                             Substitution Refs.
* patsubst:                             Text Functions.
* PC:                                   Implicit Variables.
* PFLAGS:                               Implicit Variables.
* RFLAGS:                               Implicit Variables.
* RM:                                   Implicit Variables.
* shell:                                Shell Function.
* SHELL:                                Execution.
* SHELL (command execution):            Execution.
* sort:                                 Text Functions.
* strip:                                Text Functions.
* subst:                                Text Functions.
* subst:                                Multiple Targets.
* suffix:                               Filename Functions.
* SUFFIXES:                             Suffix Rules.
* TANGLE:                               Implicit Variables.
* TEX:                                  Implicit Variables.
* TEXI2DVI:                             Implicit Variables.
* unexport:                             Variables/Recursion.
* vpath:                                Directory Search.
* VPATH:                                Directory Search.
* vpath:                                Selective Search.
* VPATH:                                General Search.
* WEAVE:                                Implicit Variables.
* wildcard:                             Filename Functions.
* wildcard:                             Wildcard Function.
* word:                                 Filename Functions.
* words:                                Filename Functions.
* YACC:                                 Implicit Variables.
* YACCR:                                Implicit Variables.
* YFLAGS:                               Implicit Variables.
* ^ (automatic variable):               Automatic.
* ^D (automatic variable):              Automatic.
* ^F (automatic variable):              Automatic.