Index of Concepts
Index Entry
Section
!
!=:
Setting
!=, expansion:
Reading Makefiles
# (comments), in makefile:
Makefile Contents
# (comments), in recipes:
Recipe Syntax
#include:
Automatic Prerequisites
$
$, 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 static pattern:
Static Usage
%, quoting in vpath:
Selective Search
%, quoting with \ (backslash):
Selective Search
%, quoting with \ (backslash):
Static Usage
%, quoting with \ (backslash):
Text Functions
* (wildcard character):
Wildcards
+
+, and define:
Canned Recipes
+, and recipe execution:
Instead of Execution
+, and recipes:
MAKE Variable
+=:
Appending
+=, expansion:
Reading Makefiles
+=, expansion:
Reading Makefiles
,
,v (RCS file extension):
Catalogue of Rules
-
- (in recipes):
Errors
-, and define:
Canned Recipes
--always-make:
Options Summary
--assume-new:
Instead of Execution
--assume-new:
Options Summary
--assume-new, and recursion:
Options/Recursion
--assume-old:
Avoiding Compilation
--assume-old:
Options Summary
--assume-old, and recursion:
Options/Recursion
--check-symlink-times:
Options Summary
--debug:
Options Summary
--directory:
Recursion
--directory:
Options Summary
--directory, and --print-directory:
-w Option
--directory, and recursion:
Options/Recursion
--dry-run:
Echoing
--dry-run:
Instead of Execution
--dry-run:
Options Summary
--environment-overrides:
Options Summary
--eval:
Options Summary
--file:
Makefile Names
--file:
Makefile Arguments
--file:
Options Summary
--file, and recursion:
Options/Recursion
--help:
Options Summary
--ignore-errors:
Errors
--ignore-errors:
Options Summary
--include-dir:
Include
--include-dir:
Options Summary
--jobs:
Parallel
--jobs:
Options Summary
--jobs, and recursion:
Options/Recursion
--just-print:
Echoing
--just-print:
Instead of Execution
--just-print:
Options Summary
--keep-going:
Errors
--keep-going:
Testing
--keep-going:
Options Summary
--load-average:
Parallel
--load-average:
Options Summary
--makefile:
Makefile Names
--makefile:
Makefile Arguments
--makefile:
Options Summary
--max-load:
Parallel
--max-load:
Options Summary
--new-file:
Instead of Execution
--new-file:
Options Summary
--new-file, and recursion:
Options/Recursion
--no-builtin-rules:
Options Summary
--no-builtin-variables:
Options Summary
--no-keep-going:
Options Summary
--no-print-directory:
-w Option
--no-print-directory:
Options Summary
--old-file:
Avoiding Compilation
--old-file:
Options Summary
--old-file, and recursion:
Options/Recursion
--output-sync:
Parallel Output
--output-sync:
Options Summary
--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:
Instead of Execution
--question:
Options Summary
--quiet:
Echoing
--quiet:
Options Summary
--recon:
Echoing
--recon:
Instead of Execution
--recon:
Options Summary
--silent:
Echoing
--silent:
Options Summary
--stop:
Options Summary
--touch:
Instead of Execution
--touch:
Options Summary
--touch, and recursion:
MAKE Variable
--trace:
Options Summary
--version:
Options Summary
--warn-undefined-variables:
Options Summary
--what-if:
Instead of Execution
--what-if:
Options Summary
-b:
Options Summary
-B:
Options Summary
-C:
Recursion
-C:
Options Summary
-C, and -w:
-w Option
-C, and recursion:
Options/Recursion
-d:
Options Summary
-e:
Options Summary
-E:
Options Summary
-e (shell flag):
Automatic Prerequisites
-f:
Makefile Names
-f:
Makefile Arguments
-f:
Options Summary
-f, and recursion:
Options/Recursion
-h:
Options Summary
-I:
Include
-i:
Errors
-i:
Options Summary
-I:
Options Summary
-j:
Parallel
-j:
Options Summary
-j, and archive update:
Archive Pitfalls
-j, and recursion:
Options/Recursion
-k:
Errors
-k:
Testing
-k:
Options Summary
-l:
Options Summary
-L:
Options Summary
-l (library search):
Libraries/Search
-l (load average):
Parallel
-m:
Options Summary
-M (to compiler):
Automatic Prerequisites
-MM (to GNU compiler):
Automatic Prerequisites
-n:
Echoing
-n:
Instead of Execution
-n:
Options Summary
-O:
Parallel Output
-o:
Avoiding Compilation
-o:
Options Summary
-O:
Options Summary
-o, and recursion:
Options/Recursion
-p:
Options Summary
-q:
Instead of Execution
-q:
Options Summary
-r:
Options Summary
-R:
Options Summary
-s:
Echoing
-s:
Options Summary
-S:
Options Summary
-t:
Instead of Execution
-t:
Options Summary
-t, and recursion:
MAKE Variable
-v:
Options Summary
-W:
Instead of Execution
-w:
Options Summary
-W:
Options Summary
-w, and -C:
-w Option
-W, and recursion:
Options/Recursion
-w, and recursion:
-w Option
-w, disabling:
-w Option
.
.a (archives):
Archive Suffix Rules
.c:
Catalogue of Rules
.C:
Catalogue of Rules
.cc:
Catalogue of Rules
.ch:
Catalogue of Rules
.cpp:
Catalogue of Rules
.d:
Automatic Prerequisites
.def:
Catalogue of Rules
.dvi:
Catalogue of Rules
.f:
Catalogue of Rules
.F:
Catalogue of Rules
.info:
Catalogue of Rules
.l:
Catalogue of Rules
.LIBPATTERNS, and link libraries:
Libraries/Search
.ln:
Catalogue of Rules
.mod:
Catalogue of Rules
.o:
Catalogue of Rules
.o:
Catalogue of Rules
.ONESHELL, use of:
One Shell
.p:
Catalogue of Rules
.PRECIOUS intermediate files:
Chained Rules
.r:
Catalogue of Rules
.s:
Catalogue of Rules
.S:
Catalogue of Rules
.sh:
Catalogue of Rules
.SHELLFLAGS, value of:
Choosing the Shell
.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
:: rules (double-colon):
Double-Colon
::=:
Flavors
::=:
Setting
:=:
Flavors
:=:
Setting
=
=:
Flavors
=:
Setting
=, expansion:
Reading Makefiles
?
? (wildcard character):
Wildcards
?=:
Flavors
?=:
Setting
?=, expansion:
Reading Makefiles
@
@ (in recipes):
Echoing
@, and define:
Canned Recipes
[
[…] (wildcard characters):
Wildcards
\
\ (backslash), for continuation lines:
Simple Makefile
\ (backslash), in recipes:
Splitting Recipe Lines
\ (backslash), to quote %:
Selective Search
\ (backslash), to quote %:
Static Usage
\ (backslash), to quote %:
Text Functions
_
__.SYMDEF:
Archive Symbols
~
~ (tilde):
Wildcards
A
abspath:
File Name Functions
algorithm for directory search:
Search Algorithm
all (standard target):
Goals
appending to variables:
Appending
ar:
Implicit Variables
archive:
Archives
archive member targets:
Archive Members
archive symbol directory updating:
Archive Symbols
archive, and -j:
Archive Pitfalls
archive, and parallel execution:
Archive Pitfalls
archive, suffix rule for:
Archive Suffix Rules
Arg list too long:
Options/Recursion
arguments of functions:
Syntax of Functions
as:
Catalogue of Rules
as:
Implicit Variables
assembly, rule to compile:
Catalogue of Rules
automatic generation of prerequisites:
Include
automatic generation of prerequisites:
Automatic Prerequisites
automatic variables:
Automatic Variables
automatic variables in prerequisites:
Automatic Variables
B
backquotes:
Shell Function
backslash (\), for continuation lines:
Simple Makefile
backslash (\), in recipes:
Splitting Recipe Lines
backslash (\), to quote %:
Selective Search
backslash (\), to quote %:
Static Usage
backslash (\), to quote %:
Text Functions
backslash (\), to quote newlines:
Splitting Lines
backslashes in pathnames and wildcard expansion:
Wildcard Pitfall
basename:
File Name Functions
binary packages:
Install Command Categories
broken pipe:
Parallel Input
bugs, reporting:
Bugs
built-in special targets:
Special Targets
C
C++, rule to compile:
Catalogue of Rules
C, rule to compile:
Catalogue of Rules
canned recipes:
Canned Recipes
cc:
Catalogue of Rules
cc:
Implicit Variables
cd (shell command):
Execution
cd (shell command):
MAKE Variable
chains of rules:
Chained Rules
check (standard target):
Goals
clean (standard target):
Goals
clean target:
Simple Makefile
clean target:
Cleanup
cleaning up:
Cleanup
clobber (standard target):
Goals
co:
Catalogue of Rules
co:
Implicit Variables
combining rules by prerequisite:
Combine By Prerequisite
command expansion:
Shell Function
command line variable definitions, and recursion:
Options/Recursion
command line variables:
Overriding
commands, sequences of:
Canned Recipes
comments, in makefile:
Makefile Contents
comments, in recipes:
Recipe Syntax
compatibility:
Features
compatibility in exporting:
Variables/Recursion
compilation, testing:
Testing
computed variable name:
Computed Names
conditional expansion:
Conditional Functions
conditional variable assignment:
Flavors
conditionals:
Conditionals
continuation lines:
Simple Makefile
controlling make:
Make Control Functions
conventions for makefiles:
Makefile Conventions
convert guile types:
Guile Types
ctangle:
Catalogue of Rules
ctangle:
Implicit Variables
cweave:
Catalogue of Rules
cweave:
Implicit Variables
D
data base of make rules:
Options Summary
deducing recipes (implicit rules):
make Deduces
default directories for included makefiles:
Include
default goal:
How Make Works
default goal:
Rules
default makefile name:
Makefile Names
default rules, last-resort:
Last Resort
define, expansion:
Reading Makefiles
defining variables verbatim:
Multi-Line
deletion of target files:
Errors
deletion of target files:
Interrupts
directive:
Makefile Contents
directories, creating installation:
Directory Variables
directories, printing them:
-w Option
directories, updating archive symbol:
Archive Symbols
directory part:
File Name 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 recipes:
Recipes/Search
directory search algorithm:
Search Algorithm
directory search, traditional (GPATH):
Search Algorithm
dist (standard target):
Goals
distclean (standard target):
Goals
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
DOS, choosing a shell in:
Choosing the Shell
double-colon rules:
Double-Colon
duplicate words, removing:
Text Functions
E
E2BIG:
Options/Recursion
echoing of recipes:
Echoing
editor:
Introduction
Emacs (M-x compile):
Errors
empty recipes:
Empty Recipes
empty targets:
Empty Targets
environment:
Environment
environment, and recursion:
Variables/Recursion
environment, SHELL in:
Choosing the Shell
error, stopping on:
Make Control Functions
errors (in recipes):
Errors
errors with wildcards:
Wildcard Pitfall
evaluating makefile syntax:
Eval Function
example of loaded objects:
Loaded Object Example
example using Guile:
Guile Example
execution, in parallel:
Parallel
execution, instead of:
Instead of Execution
execution, of recipes:
Execution
exit status (errors):
Errors
exit status of make:
Running
expansion, secondary:
Secondary Expansion
explicit rule, definition of:
Makefile Contents
explicit rule, expansion:
Reading Makefiles
explicit rules, secondary expansion of:
Secondary Expansion
exporting variables:
Variables/Recursion
extensions, Guile:
Guile Integration
extensions, load directive:
load Directive
extensions, loading:
Loading Objects
F
f77:
Catalogue of Rules
f77:
Implicit Variables
FDL, GNU Free Documentation License:
GNU Free Documentation License
features of GNU make:
Features
features, missing:
Missing
file name functions:
File Name Functions
file name of makefile:
Makefile Names
file name of makefile, how to specify:
Makefile Names
file name prefix, adding:
File Name Functions
file name suffix:
File Name Functions
file name suffix, adding:
File Name Functions
file name with wildcards:
Wildcards
file name, abspath of:
File Name Functions
file name, basename of:
File Name Functions
file name, directory part:
File Name Functions
file name, nondirectory part:
File Name Functions
file name, realpath of:
File Name Functions
file, reading from:
File Function
file, writing to:
File Function
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
flavor of variable:
Flavor Function
flavors of variables:
Flavors
FORCE:
Force Targets
force targets:
Force Targets
Fortran, rule to compile:
Catalogue of Rules
functions:
Functions
functions, for controlling make:
Make Control Functions
functions, for file names:
File Name Functions
functions, for text:
Text Functions
functions, syntax of:
Syntax of Functions
functions, user defined:
Call Function
G
g++:
Catalogue of Rules
g++:
Implicit Variables
gcc:
Catalogue of Rules
generating prerequisites automatically:
Include
generating prerequisites automatically:
Automatic Prerequisites
get:
Catalogue of Rules
get:
Implicit Variables
globbing (wildcards):
Wildcards
goal:
How Make Works
goal, default:
How Make Works
goal, default:
Rules
goal, how to specify:
Goals
grouped targets:
Multiple Targets
Guile:
Guile Function
Guile:
Guile Integration
Guile example:
Guile Example
guile, conversion of types:
Guile Types
H
home directory:
Wildcards
I
IEEE Standard 1003.2:
Overview
ifdef, expansion:
Reading Makefiles
ifeq, expansion:
Reading Makefiles
ifndef, expansion:
Reading Makefiles
ifneq, expansion:
Reading Makefiles
implicit rule:
Implicit Rules
implicit rule, and directory search:
Implicit/Search
implicit rule, and VPATH:
Implicit/Search
implicit rule, definition of:
Makefile Contents
implicit rule, expansion:
Reading Makefiles
implicit rule, how to use:
Using Implicit
implicit rule, introduction to:
make Deduces
implicit rule, predefined:
Catalogue of Rules
implicit rule, search algorithm:
Implicit Rule Search
implicit rules, secondary expansion of:
Secondary Expansion
included makefiles, default directories:
Include
including (MAKEFILES variable):
MAKEFILES Variable
including (MAKEFILE_LIST variable):
Special Variables
including other makefiles:
Include
incompatibilities:
Missing
independent targets:
Multiple Targets
Info, rule to format:
Catalogue of Rules
inheritance, suppressing:
Suppressing Inheritance
input during parallel execution:
Parallel Input
install (standard target):
Goals
installation directories, creating:
Directory Variables
installations, staged:
DESTDIR
interface for loaded objects:
Loaded Object API
intermediate files:
Chained Rules
intermediate files, preserving:
Chained Rules
intermediate targets, explicit:
Special Targets
interrupt:
Interrupts
J
job slots:
Parallel
job slots, and recursion:
Options/Recursion
job slots, sharing:
Job Slots
jobs, limiting based on load:
Parallel
jobserver:
Job Slots
jobserver on POSIX:
POSIX Jobserver
jobserver on Windows:
Windows Jobserver
joining lists of words:
File Name Functions
K
killing (interruption):
Interrupts
L
last-resort default rules:
Last Resort
ld:
Catalogue of Rules
lex:
Catalogue of Rules
lex:
Implicit Variables
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
link libraries, patterns matching:
Libraries/Search
linking, predefined rule for:
Catalogue of Rules
lint:
Catalogue of Rules
lint:
Implicit Variables
lint, rule to run:
Catalogue of Rules
list of all prerequisites:
Automatic Variables
list of changed prerequisites:
Automatic Variables
load average:
Parallel
load directive:
load Directive
loaded object API:
Loaded Object API
loaded object example:
Loaded Object Example
loaded object licensing:
Loaded Object API
loaded objects:
Loading Objects
loaded objects, remaking of:
Remaking Loaded Objects
long lines, splitting:
Splitting Lines
loops in variable expansion:
Flavors
lpr (shell command):
Wildcard Examples
lpr (shell command):
Empty Targets
M
m2c:
Catalogue of Rules
m2c:
Implicit Variables
macro:
Using Variables
make depend:
Automatic Prerequisites
make extensions:
Extending make
make integration:
Integrating make
make interface to guile:
Guile Interface
make procedures in guile:
Guile Interface
makefile:
Introduction
makefile name:
Makefile Names
makefile name, how to specify:
Makefile Names
makefile rule parts:
Rule Introduction
makefile syntax, evaluating:
Eval Function
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, reading:
Reading Makefiles
makefile, remaking of:
Remaking Makefiles
makefile, simple:
Simple Makefile
makefiles, and MAKEFILE_LIST variable:
Special Variables
makefiles, and special variables:
Special Variables
makefiles, parsing:
Parsing Makefiles
makeinfo:
Catalogue of Rules
makeinfo:
Implicit Variables
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
mostlyclean (standard target):
Goals
multi-line variable definition:
Multi-Line
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
N
name of makefile:
Makefile Names
name of makefile, how to specify:
Makefile Names
nested variable reference:
Computed Names
newline, quoting, in makefile:
Simple Makefile
newline, quoting, in recipes:
Splitting Recipe Lines
nondirectory part:
File Name Functions
normal prerequisites:
Prerequisite Types
O
obj:
Variables Simplify
OBJ:
Variables Simplify
objects:
Variables Simplify
OBJECTS:
Variables Simplify
objects, loaded:
Loading Objects
objs:
Variables Simplify
OBJS:
Variables Simplify
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 Match
order-only prerequisites:
Prerequisite Types
origin of variable:
Origin Function
output during parallel execution:
Parallel Output
output during parallel execution:
Options Summary
overriding makefiles:
Overriding Makefiles
overriding variables with arguments:
Overriding
overriding with override:
Override Directive
P
parallel execution:
Parallel
parallel execution, and archive update:
Archive Pitfalls
parallel execution, input during:
Parallel Input
parallel execution, output during:
Parallel Output
parallel execution, output during:
Options Summary
parallel execution, overriding:
Special Targets
parallel output to terminal:
Terminal Output
parsing makefiles:
Parsing Makefiles
parts of makefile rule:
Rule Introduction
Pascal, rule to compile:
Catalogue of Rules
pattern rule:
Pattern Intro
pattern rule, expansion:
Reading Makefiles
pattern rules, order of:
Pattern Match
pattern rules, static (not implicit):
Static Pattern
pattern rules, static, syntax of:
Static Usage
pattern-specific variables:
Pattern-specific
pc:
Catalogue of Rules
pc:
Implicit Variables
phony targets:
Phony Targets
phony targets and recipe execution:
Instead of Execution
pitfalls of wildcards:
Wildcard Pitfall
plugin_is_GPL_compatible:
Loaded Object API
portability:
Features
POSIX:
Overview
POSIX:
Options/Recursion
POSIX-conforming mode, setting:
Special Targets
post-installation commands:
Install Command Categories
pre-installation commands:
Install Command Categories
precious targets:
Special Targets
predefined rules and variables, printing:
Options Summary
prefix, adding:
File Name Functions
prerequisite:
Rules
prerequisite pattern, implicit:
Pattern Intro
prerequisite pattern, static (not implicit):
Static Usage
prerequisite types:
Prerequisite Types
prerequisite, expansion:
Reading Makefiles
prerequisites:
Rule Syntax
prerequisites, and automatic variables:
Automatic Variables
prerequisites, automatic generation:
Include
prerequisites, automatic generation:
Automatic Prerequisites
prerequisites, introduction to:
Rule Introduction
prerequisites, list of all:
Automatic Variables
prerequisites, list of changed:
Automatic Variables
prerequisites, normal:
Prerequisite Types
prerequisites, order-only:
Prerequisite Types
prerequisites, varying (static pattern):
Static Pattern
preserving intermediate files:
Chained Rules
preserving with .PRECIOUS:
Special Targets
preserving with .PRECIOUS:
Chained Rules
preserving with .SECONDARY:
Special Targets
print (standard target):
Goals
print target:
Wildcard Examples
print target:
Empty Targets
printing directories:
-w Option
printing messages:
Make Control Functions
printing of recipes:
Echoing
printing user warnings:
Make Control Functions
problems and bugs, reporting:
Bugs
problems with wildcards:
Wildcard Pitfall
processing a makefile:
How Make Works
Q
question mode:
Instead of Execution
quoting %, in patsubst:
Text Functions
quoting %, in static pattern:
Static Usage
quoting %, in vpath:
Selective Search
quoting newline, in makefile:
Simple Makefile
quoting newline, in recipes:
Splitting Recipe Lines
R
Ratfor, rule to compile:
Catalogue of Rules
RCS, rule to extract from:
Catalogue of Rules
reading from a file:
File Function
reading makefiles:
Reading Makefiles
README:
Makefile Names
realclean (standard target):
Goals
realpath:
File Name Functions
recipe:
Simple Makefile
recipe execution, single invocation:
Special Targets
recipe lines, single shell:
One Shell
recipe syntax:
Recipe Syntax
recipe, execution:
Execution
recipes:
Rule Syntax
recipes:
Recipes
recipes setting shell variables:
Execution
recipes, and directory search:
Recipes/Search
recipes, backslash (\) in:
Splitting Recipe Lines
recipes, canned:
Canned Recipes
recipes, comments in:
Recipe Syntax
recipes, echoing:
Echoing
recipes, empty:
Empty Recipes
recipes, errors in:
Errors
recipes, execution in parallel:
Parallel
recipes, how to write:
Recipes
recipes, instead of executing:
Instead of Execution
recipes, introduction to:
Rule Introduction
recipes, quoting newlines in:
Splitting Recipe Lines
recipes, splitting:
Splitting Recipe Lines
recipes, using variables in:
Variables in Recipes
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 -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 command line variable definitions:
Options/Recursion
recursion, and environment:
Variables/Recursion
recursion, and MAKE variable:
MAKE Variable
recursion, and MAKEFILES variable:
MAKEFILES Variable
recursion, and options:
Options/Recursion
recursion, and printing directories:
-w Option
recursion, and variables:
Variables/Recursion
recursion, level of:
Variables/Recursion
recursive variable expansion:
Using Variables
recursive variable expansion:
Flavors
recursively expanded variables:
Flavors
reference to variables:
Reference
reference to variables:
Advanced
relinking:
How Make Works
remaking loaded objects:
Remaking Loaded Objects
remaking makefiles:
Remaking Makefiles
removal of target files:
Errors
removal of target files:
Interrupts
removing duplicate words:
Text Functions
removing targets on failure:
Special Targets
removing whitespace from split lines:
Splitting Lines
removing, to clean up:
Cleanup
reporting bugs:
Bugs
rm:
Implicit Variables
rm (shell command):
Simple Makefile
rm (shell command):
Wildcard Examples
rm (shell command):
Phony Targets
rm (shell command):
Errors
rule prerequisites:
Rule Syntax
rule syntax:
Rule Syntax
rule targets:
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 directory search:
Implicit/Search
rule, implicit, and VPATH:
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 recipe or prerequisites:
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
rules, and $:
Rule Syntax
S
s. (SCCS file prefix):
Catalogue of Rules
SCCS, rule to extract from:
Catalogue of Rules
search algorithm, implicit rule:
Implicit Rule Search
search path for prerequisites (VPATH):
Directory Search
search path for prerequisites (VPATH), and implicit rules:
Implicit/Search
search path for prerequisites (VPATH), and link libraries:
Libraries/Search
searching for strings:
Text Functions
secondary expansion:
Secondary Expansion
secondary expansion and explicit rules:
Secondary Expansion
secondary expansion and implicit rules:
Secondary Expansion
secondary expansion and static pattern rules:
Secondary Expansion
secondary files:
Chained Rules
secondary targets:
Special Targets
sed (shell command):
Automatic Prerequisites
selecting a word:
Text Functions
selecting word lists:
Text Functions
sequences of commands:
Canned Recipes
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
shar (standard target):
Goals
shell command, function for:
Shell Function
shell file name pattern (in include):
Include
shell variables, setting in recipes:
Execution
shell wildcards (in include):
Include
shell, choosing the:
Choosing the Shell
SHELL, exported value:
Variables/Recursion
SHELL, import from environment:
Environment
shell, in DOS and Windows:
Choosing the Shell
SHELL, MS-DOS specifics:
Choosing the Shell
SHELL, value of:
Choosing the Shell
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
special variables:
Special Variables
specifying makefile name:
Makefile Names
splitting long lines:
Splitting Lines
splitting recipes:
Splitting Recipe Lines
staged installs:
DESTDIR
standard input:
Parallel Input
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
static pattern rules, secondary expansion of:
Secondary Expansion
stem:
Static Usage
stem:
Pattern Match
stem, shortest:
Pattern Match
stem, variable for:
Automatic Variables
stopping make:
Make Control Functions
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:
File Name Functions
suffix, function to find:
File Name Functions
suffix, substituting in variables:
Substitution Refs
suppressing inheritance:
Suppressing Inheritance
switches:
Options Summary
symbol directories, updating archive:
Archive Symbols
syntax of recipe:
Recipe Syntax
syntax of rules:
Rule Syntax
T
tab character (in commands):
Rule Syntax
tabs in rules:
Rule Introduction
TAGS (standard target):
Goals
tangle:
Catalogue of Rules
tangle:
Implicit Variables
tar (standard target):
Goals
target:
Rules
target pattern, implicit:
Pattern Intro
target pattern, static (not implicit):
Static Usage
target, deleting on error:
Errors
target, deleting on interrupt:
Interrupts
target, expansion:
Reading Makefiles
target, multiple in pattern rule:
Pattern Intro
target, multiple rules for one:
Multiple Rules
target, touching:
Instead of Execution
target-specific variables:
Target-specific
targets:
Rule Syntax
targets without a file:
Phony Targets
targets, built-in special:
Special Targets
targets, empty:
Empty Targets
targets, force:
Force Targets
targets, grouped:
Multiple Targets
targets, independent:
Multiple Targets
targets, introduction to:
Rule Introduction
targets, multiple:
Multiple Targets
targets, phony:
Phony Targets
terminal rule:
Match-Anything Rules
terminal, output to:
Terminal Output
test (standard target):
Goals
testing compilation:
Testing
tex:
Catalogue of Rules
tex:
Implicit Variables
TeX, rule to run:
Catalogue of Rules
texi2dvi:
Catalogue of Rules
texi2dvi:
Implicit Variables
Texinfo, rule to format:
Catalogue of Rules
tilde (~):
Wildcards
tools, sharing job slots:
Job Slots
touch (shell command):
Wildcard Examples
touch (shell command):
Empty Targets
touching files:
Instead of Execution
traditional directory search (GPATH):
Search Algorithm
types of prerequisites:
Prerequisite Types
types, conversion of:
Guile Types
U
undefined variables, warning message:
Options Summary
undefining variable:
Undefine Directive
updating archive symbol directories:
Archive Symbols
updating loaded objects:
Remaking Loaded Objects
updating makefiles:
Remaking Makefiles
user defined functions:
Call Function
V
value:
Using Variables
value, how a variable gets it:
Values
variable:
Using Variables
variable definition:
Makefile Contents
variable references in recipes:
Variables in Recipes
variables:
Variables Simplify
variables, ‘$’ in name:
Computed Names
variables, and implicit rule:
Automatic Variables
variables, appending to:
Appending
variables, automatic:
Automatic Variables
variables, command line:
Overriding
variables, command line, and recursion:
Options/Recursion
variables, computed names:
Computed Names
variables, conditional assignment:
Flavors
variables, defining verbatim:
Multi-Line
variables, environment:
Variables/Recursion
variables, environment:
Environment
variables, exporting:
Variables/Recursion
variables, flavor of:
Flavor Function
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, multi-line:
Multi-Line
variables, nested references:
Computed Names
variables, origin of:
Origin Function
variables, overriding:
Override Directive
variables, overriding with arguments:
Overriding
variables, pattern-specific:
Pattern-specific
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, target-specific:
Target-specific
variables, unexpanded value:
Value Function
variables, warning for undefined:
Options Summary
varying prerequisites:
Static Pattern
verbatim variable definition:
Multi-Line
vpath:
Directory Search
VPATH, and implicit rules:
Implicit/Search
VPATH, and link libraries:
Libraries/Search
W
warnings, printing:
Make Control Functions
weave:
Catalogue of Rules
weave:
Implicit Variables
Web, rule to run:
Catalogue of Rules
what if:
Instead of Execution
whitespace, avoiding on line split:
Splitting Lines
whitespace, in variable values:
Flavors
whitespace, stripping:
Text Functions
wildcard:
Wildcards
wildcard pitfalls:
Wildcard Pitfall
wildcard, function:
File Name Functions
wildcard, in archive member:
Archive Members
wildcard, in include:
Include
wildcards and MS-DOS/MS-Windows backslashes:
Wildcard Pitfall
Windows, choosing a shell in:
Choosing the Shell
word, selecting a:
Text Functions
words, extracting first:
Text Functions
words, extracting last:
Text Functions
words, filtering:
Text Functions
words, filtering out:
Text Functions
words, finding number:
Text Functions
words, iterating over:
Foreach Function
words, joining lists:
File Name Functions
words, removing duplicates:
Text Functions
words, selecting lists of:
Text Functions
writing recipes:
Recipes
writing rules:
Rules
writing to a file:
File Function
Y
yacc:
Catalogue of Rules
yacc:
Implicit Variables
yacc:
Canned Recipes
Yacc, rule to run:
Catalogue of Rules
