Concept Index (GNU make)

Index of Concepts

Jump to:

# $ % * + , - . : = ? @ [ \\ _ ~
A B C D E F G H I J K L M N O P Q R S T U V W Y

	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

Jump to:

!

# $ % * + , - . : = ? @ [ \\ _ ~
A B C D E F G H I J K L M N O P Q R S T U V W Y