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