Concept Index - Amake: GNU Make with Automatic Dependency Analysis

Next: Name Index, Previous: GNU Free Documentation License, Up: Top

Index of Concepts

# (comments), in commands: Command Syntax
# (comments), in makefile: Makefile Contents
#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): Text Functions
%, quoting with \ (backslash): Static Usage
%, quoting with \ (backslash): Selective Search
* (wildcard character): Wildcards
+, and command execution: Instead of Execution
+, and commands: MAKE Variable
+, and define: Sequences
+=: Appending
+=, expansion: Reading Makefiles
,v (RCS file extension): Catalogue of Rules
- (in commands): Errors
-, and define: Sequences
--always-make: Options Summary
--assume-new: Options Summary
--assume-new: Instead of Execution
--assume-new, and recursion: Options/Recursion
--assume-old: Options Summary
--assume-old: Avoiding Compilation
--assume-old, and recursion: Options/Recursion
--check-symlink-times: Options Summary
--debug: Debugging
--debug: Options Summary
--directory: Options Summary
--directory: Recursion
--directory, and --print-directory: -w Option
--directory, and recursion: Options/Recursion
--dry-run: Options Summary
--dry-run: Instead of Execution
--dry-run: Echoing
--environment-overrides: Options Summary
--file: Options Summary
--file: Makefile Arguments
--file: Makefile Names
--file, and recursion: Options/Recursion
--help: Options Summary
--ignore-errors: Options Summary
--ignore-errors: Errors
--include-dir: Options Summary
--include-dir: Include
--jobs: Options Summary
--jobs: Parallel
--jobs, and recursion: Options/Recursion
--just-print: Options Summary
--just-print: Instead of Execution
--just-print: Echoing
--keep-going: Options Summary
--keep-going: Testing
--keep-going: Errors
--load-average: Options Summary
--load-average: Parallel
--makefile: Options Summary
--makefile: Makefile Arguments
--makefile: Makefile Names
--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-builtin-variables: Options Summary
--no-keep-going: Options Summary
--no-print-directory: Options Summary
--no-print-directory: -w Option
--old-file: Options Summary
--old-file: Avoiding Compilation
--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: Options Summary
--quiet: Echoing
--recon: Options Summary
--recon: Instead of Execution
--recon: Echoing
--silent: Options Summary
--silent: Echoing
--stop: Options Summary
--touch: Options Summary
--touch: Instead of Execution
--touch, and recursion: MAKE Variable
--version: Options Summary
--warn-undefined-variables: Options Summary
--what-if: Options Summary
--what-if: Instead of Execution
-B: 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 Prerequisites
-f: Options Summary
-f: Makefile Arguments
-f: Makefile Names
-f, and recursion: Options/Recursion
-h: Options Summary
-I: Options Summary
-i: Options Summary
-i: Errors
-I: Include
-j: Options Summary
-j: Parallel
-j, and archive update: Archive Pitfalls
-j, and recursion: Options/Recursion
-k: Options Summary
-k: Testing
-k: Errors
-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: Options Summary
-n: Instead of Execution
-n: Echoing
-o: Options Summary
-o: Avoiding Compilation
-o, and recursion: Options/Recursion
-p: Options Summary
-q: Options Summary
-q: Instead of Execution
-R: Options Summary
-r: Options Summary
-S: Options Summary
-s: Options Summary
-s: Echoing
-t: Options Summary
-t: Instead of Execution
-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: -w Option
-W, and recursion: Options/Recursion
-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
.cmd files: Implementation
.cmd files: Operation
.cpp: Catalogue of Rules
.d: Automatic Prerequisites
.def: Catalogue of Rules
.dep file: Amake-Collect
.dep files: Implementation
.dep files: Operation
.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
.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
.sib file: Amake-Collect
.sib files: Implementation
.sib files: Operation
.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
:=: Setting
:=: Flavors
=: Setting
=: Flavors
=, expansion: Reading Makefiles
? (wildcard character): Wildcards
?=: Setting
?=: Flavors
?=, expansion: Reading Makefiles
@ (in commands): Echoing
@, and define: Sequences
[...] (wildcard characters): Wildcards
\ (backslash), for continuation lines: Simple Makefile
\ (backslash), in commands: Splitting Lines
\ (backslash), to quote %: Text Functions
\ (backslash), to quote %: Static Usage
\ (backslash), to quote %: Selective Search
__.SYMDEF: Archive Symbols
abspath: File Name Functions
algorithm for directory search: Search Algorithm
all (standard target): Goals
amake: Amake Features
amake cache: Implementation
amake checksum: Implementation
amake debugging: Debugging
amake example: Operation
amake execution architecture: Execution Architecture
amake implementation: Implementation
amake last-modification-time: Implementation
amake makefile variables: Makefile Variables
amake semaphores: Amake-Collect
amake semaphores: Implementation
amake-collect: Amake-Collect
amake-collect: Implementation
amake-collect: Usage
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: Implicit Variables
as: Catalogue of Rules
assembly, rule to compile: Catalogue of Rules
automatic dependency analysis: Amake Features
automatic generation of prerequisites: Automatic Prerequisites
automatic generation of prerequisites: Include
automatic variables: Automatic Variables
automatic variables in prerequisites: Automatic Variables
backquotes: Shell Function
backslash (\), for continuation lines: Simple Makefile
backslash (\), in commands: Splitting Lines
backslash (\), to quote %: Text Functions
backslash (\), to quote %: Static Usage
backslash (\), to quote %: Selective Search
backslashes in pathnames and wildcard expansion: Wildcard Pitfall
basename: File Name Functions
binary packages: Install Command Categories
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
cd (shell command): MAKE Variable
cd (shell command): Execution
chains of rules: Chained Rules
check (standard target): Goals
clean (standard target): Goals
clean target: Cleanup
clean target: Simple Makefile
cleaning up: Cleanup
clobber (standard target): Goals
co: Implicit Variables
co: Catalogue of Rules
combining rules by prerequisite: Combine By Prerequisite
command line variable definitions, and recursion: Options/Recursion
command line variables: Overriding
command syntax: Command Syntax
commands: Rule Syntax
commands setting shell variables: Execution
commands, backslash (\) in: Splitting Lines
commands, comments in: Command Syntax
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: Splitting Lines
commands, sequences of: Sequences
commands, splitting: Splitting Lines
commands, using variables in: Variables in Commands
commands-executed dependencies: Operation
comments, in commands: Command Syntax
comments, in makefile: Makefile Contents
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
ctangle: Implicit Variables
ctangle: Catalogue of Rules
cweave: Implicit Variables
cweave: Catalogue of Rules
data base of make rules: Options Summary
deducing commands (implicit rules): make Deduces
default directories for included makefiles: Include
default goal: Rules
default goal: How Make Works
default makefile name: Makefile Names
default rules, last-resort: Last Resort
define, expansion: Reading Makefiles
defining variables verbatim: Defining
deletion of target files: Interrupts
deletion of target files: Errors
directive: Makefile Contents
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 shell commands: Commands/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
E2BIG: Options/Recursion
echoing of commands: Echoing
editor: Introduction
Emacs (M-x compile): Errors
empty commands: Empty Commands
empty targets: Empty Targets
enabling amake features: Usage
environment: Environment
environment, and recursion: Variables/Recursion
environment, SHELL in: Choosing the Shell
environment-variable-value dependencies: Operation
error, stopping on: Make Control Functions
errors (in commands): Errors
errors with wildcards: Wildcard Pitfall
evaluating makefile syntax: Eval Function
execution, in parallel: Parallel
execution, instead of: Instead of Execution
execution, of commands: 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
f77: Implicit Variables
f77: Catalogue of Rules
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
files, assuming new: Instead of Execution
files, assuming old: Avoiding Compilation
files, avoiding recompilation of: Avoiding Compilation
files, intermediate: Chained Rules
files-accessed dependencies: Operation
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++: Implicit Variables
g++: Catalogue of Rules
gcc: Catalogue of Rules
generating prerequisites automatically: Automatic Prerequisites
generating prerequisites automatically: Include
get: Implicit Variables
get: Catalogue of Rules
globbing (wildcards): Wildcards
goal: How Make Works
goal, default: Rules
goal, default: How Make Works
goal, how to specify: Goals
home directory: Wildcards
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 (MAKEFILE_LIST variable): MAKEFILE_LIST Variable
including (MAKEFILES variable): MAKEFILES Variable
including other makefiles: Include
incompatibilities: Missing
Info, rule to format: Catalogue of Rules
install (standard target): Goals
intermediate files: Chained Rules
intermediate files, preserving: Chained Rules
intermediate targets, explicit: Special Targets
interrupt: Interrupts
job slots: Parallel
job slots, and recursion: Options/Recursion
jobs, limiting based on load: Parallel
joining lists of words: File Name Functions
killing (interruption): Interrupts
last-resort default rules: Last Resort
ld: Catalogue of Rules
LD_LIBRARY_PATH: Usage
lex: Implicit Variables
lex: Catalogue of Rules
Lex, rule to run: Catalogue of Rules
libaccess: Usage
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: Implicit Variables
lint: Catalogue of Rules
lint, rule to run: Catalogue of Rules
Linux kernel: Operation
list of all prerequisites: Automatic Variables
list of changed prerequisites: Automatic Variables
load average: Parallel
loops in variable expansion: Flavors
lpr (shell command): Empty Targets
lpr (shell command): Wildcard Examples
m2c: Implicit Variables
m2c: Catalogue of Rules
macro: Using Variables
make depend: Automatic Prerequisites
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, parsing: Reading Makefiles
makefile, remaking of: Remaking Makefiles
makefile, simple: Simple Makefile
makefiles, and MAKEFILE_LIST variable: MAKEFILE_LIST Variable
makefiles, and special variables: Special Variables
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
mostlyclean (standard target): Goals
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: Splitting Lines
newline, quoting, in makefile: Simple Makefile
nondirectory part: File Name Functions
normal prerequisites: Prerequisite Types
OBJ: Variables Simplify
obj: Variables Simplify
OBJECTS: Variables Simplify
objects: Variables Simplify
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 Intro
order-only prerequisites: Prerequisite Types
origin of variable: Origin Function
overriding makefiles: Overriding Makefiles
overriding variables with arguments: Overriding
overriding with override: Override Directive
parallel execution: Parallel
parallel execution, and archive update: Archive Pitfalls
parallel execution, overriding: Special Targets
parts of makefile rule: Rule Introduction
Pascal, rule to compile: Catalogue of Rules
PATH: Usage
pattern rule: Pattern Intro
pattern rule, expansion: Reading Makefiles
pattern rules, order of: Pattern Intro
pattern rules, static (not implicit): Static Pattern
pattern rules, static, syntax of: Static Usage
pattern-specific variables: Pattern-specific
pc: Implicit Variables
pc: Catalogue of Rules
phony targets: Phony Targets
pitfalls of wildcards: Wildcard Pitfall
portability: Features
POSIX: Overview
POSIX.2: Options/Recursion
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: Automatic Prerequisites
prerequisites, automatic generation: Include
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: Chained Rules
preserving with .PRECIOUS: Special Targets
preserving with .SECONDARY: Special Targets
print (standard target): Goals
print target: Empty Targets
print target: Wildcard Examples
printing directories: -w Option
printing messages: Make Control Functions
printing of commands: Echoing
printing user warnings: Make Control Functions
problems and bugs, reporting: Bugs
problems with wildcards: Wildcard Pitfall
processing a makefile: How Make Works
programs-executed dependencies: Operation
question mode: Instead of Execution
quoting %, in patsubst: Text Functions
quoting %, in static pattern: Static Usage
quoting %, in vpath: Selective Search
quoting newline, in commands: Splitting Lines
quoting newline, in makefile: Simple Makefile
Ratfor, rule to compile: Catalogue of Rules
RCS, rule to extract from: Catalogue of Rules
reading makefiles: Reading Makefiles
README: Makefile Names
realclean (standard target): Goals
realpath: File Name Functions
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: -w Option
recursion, and -W: Options/Recursion
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: Flavors
recursive variable expansion: Using Variables
recursively expanded variables: Flavors
reference to variables: Advanced
reference to variables: Reference
relinking: How Make Works
remaking makefiles: Remaking Makefiles
removal of target files: Interrupts
removal of target files: Errors
removing duplicate words: Text Functions
removing targets on failure: Special Targets
removing, to clean up: Cleanup
reporting bugs: Bugs
rm: Implicit Variables
rm (shell command): Errors
rm (shell command): Phony Targets
rm (shell command): Wildcard Examples
rm (shell command): Simple Makefile
rule commands: Commands
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 commands 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. (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: 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
shar (standard target): Goals
shared-libraries-opened dependencies: Operation
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 variables, setting in commands: 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 commands: Splitting Lines
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
static pattern rules, secondary expansion of: Secondary Expansion
stem: Pattern Match
stem: Static Usage
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
switches: Options Summary
symbol directories, updating archive: Archive Symbols
syntax of commands: Command Syntax
syntax of rules: Rule Syntax
tab character (in commands): Rule Syntax
tabs in rules: Rule Introduction
TAGS (standard target): Goals
tangle: Implicit Variables
tangle: Catalogue of Rules
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-cache subsystem: Target-Cache Subsystem
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, introduction to: Rule Introduction
targets, multiple: Multiple Targets
targets, phony: Phony Targets
terminal rule: Match-Anything Rules
test (standard target): Goals
testing compilation: Testing
tex: Implicit Variables
tex: Catalogue of Rules
TeX, rule to run: Catalogue of Rules
texi2dvi: Implicit Variables
texi2dvi: Catalogue of Rules
Texinfo, rule to format: Catalogue of Rules
tilde (~): Wildcards
touch (shell command): Empty Targets
touch (shell command): Wildcard Examples
touching files: Instead of Execution
traditional directory search (GPATH): Search Algorithm
types of prerequisites: Prerequisite Types
undefined variables, warning message: Options Summary
updating archive symbol directories: Archive Symbols
updating makefiles: Remaking Makefiles
user defined functions: Call Function
value: Using Variables
value, how a variable gets it: Values
variable: Using Variables
variable definition: Makefile Contents
variable references in commands: Variables in Commands
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: Defining
variables, environment: Environment
variables, environment: Variables/Recursion
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, 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: Defining
vpath: Directory Search
VPATH, and implicit rules: Implicit/Search
VPATH, and link libraries: Libraries/Search
warnings, printing: Make Control Functions
weave: Implicit Variables
weave: Catalogue of Rules
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: 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 rule commands: Commands
writing rules: Rules
yacc: Implicit Variables
yacc: Catalogue of Rules
yacc: Sequences
Yacc, rule to run: Catalogue of Rules
~ (tilde): Wildcards