Next: Overview Prev: (dir) Up: (dir)


   The GNU `make' utility automatically determines which pieces of a
large program need to be recompiled, and issues the commands to
recompile them.

   This is Edition 0.45 of the `GNU Make Manual', last updated 11 May
1994 for `make' Version 3.71 Beta.

   This manual describes `make' and contains the following chapters:

* Overview
Overview of `make'.
* Introduction
An introduction to `make'.
* Makefiles
Makefiles tell `make' what to do.
* Rules
Rules describe when a file must be remade.
* Commands
Commands say how to remake a file.
* Using Variables
You can use variables to avoid repetition.
* Conditionals
Use or ignore parts of the makefile based on the values of variables.
* Functions
Many powerful ways to manipulate text.
* make Invocation
RunningHow to invoke `make' on the command line.
* Implicit Rules
Use implicit rules to treat many files alike, based on their file names.
* Archives
How `make' can update library archives.
* Features
Features GNU `make' has over other `make's.
* Missing
What GNU `make' lacks from other `make's.
* Makefile Conventions
Conventions for makefiles in GNU programs.
* Quick Reference
A quick reference for experienced users.
* Complex Makefile
A real example of a straightforward, but nontrivial, makefile.
* Concept Index
Index of Concepts
* Name Index
Index of Functions, Variables, & Directives
 -- The Detailed Node Listing --

Overview of `make'

* Preparing
Preparing and Running Make
* Reading
On Reading this Text
* Bugs
Problems and Bugs
An Introduction to Makefiles

* Rule Introduction
What a rule looks like.
* Simple Makefile
A Simple Makefile
* How Make Works
How `make' Processes This Makefile
* Variables Simplify
Variables Make Makefiles Simpler
* make Deduces
Letting `make' Deduce the Commands
* Combine By Dependency
Another Style of Makefile
* Cleanup
Rules for Cleaning the Directory
Writing Makefiles

* Makefile Contents
What makefiles contain.
* Makefile Names
How to name your makefile.
* Include
How one makefile can use another makefile.
* MAKEFILES Variable
The environment can specify extra makefiles.
* Remaking Makefiles
How makefiles get remade.
* Overriding Makefiles
How to override part of one makefile with another makefile.
Writing Rules

* Rule Example
An example explained.
* Rule Syntax
General syntax explained.
* Wildcards
Using wildcard characters such as `*'.
* Directory Search
Searching other directories for source files.
* Phony Targets
Using a target that is not a real file's name.
* Force Targets
You can use a target without commands or dependencies to mark other targets as phony.
* Empty Targets
When only the date matters and the files are empty.
* Special Targets
Targets with special built-in meanings.
* Multiple Targets
When to make use of several targets in a rule.
* Multiple Rules
How to use several rules with the same target.
* Static Pattern
Static pattern rules apply to multiple targets and can vary the dependencies according to the target name.
* Double-Colon
How to use a special kind of rule to allow several independent rules for one target.
* Automatic Dependencies
How to automatically generate rules giving dependencies from the source files themselves.
Using Wildcard Characters in File Names

* Wildcard Examples
Several examples
* Wildcard Pitfall
Problems to avoid.
* Wildcard Function
How to cause wildcard expansion where it does not normally take place.
Searching Directories for Dependencies

* General Search
Specifying a search path that applies to every dependency.
* Selective Search
Specifying a search path for a specified class of names.
* Commands/Search
How to write shell commands that work together with search paths.
* Implicit/Search
How search paths affect implicit rules.
* Libraries/Search
Directory search for link libraries.
Static Pattern Rules

* Static Usage
The syntax of static pattern rules.
* Static versus Implicit
When are they better than implicit rules?
Writing the Commands in Rules

* Echoing
How to control when commands are echoed.
* Execution
How commands are executed.
* Parallel
How commands can be executed in parallel.
* Errors
What happens after a command execution error.
* Interrupts
What happens when a command is interrupted.
* Recursion
Invoking `make' from makefiles.
* Sequences
Defining canned sequences of commands.
* Empty Commands
Defining useful, do-nothing commands.
Recursive Use of `make'

* MAKE Variable
The special effects of using `$(MAKE)'.
* Variables/Recursion
How to communicate variables to a sub-`make'.
* Options/Recursion
How to communicate options to a sub-`make'.
* -w Option
How the `-w' or `--print-directory' option helps debug use of recursive `make' commands.
How to Use Variables

* Reference
How to use the value of a variable.
* Flavors
Variables come in two flavors.
* Advanced
Advanced features for referencing a variable.
* Values
All the ways variables get their values.
* Setting
How to set a variable in the makefile.
* Appending
How to append more text to the old value of a variable.
* Override Directive
How to set a variable in the makefile even if the user has set it with a command argument.
* Defining
An alternate way to set a variable to a verbatim string.
* Environment
Variable values can come from the environment.
Advanced Features for Reference to Variables

* Substitution Refs
Referencing a variable with substitutions on the value.
* Computed Names
Computing the name of the variable to refer to.
Conditional Parts of Makefiles

* Conditional Example
Example of a conditional
* Conditional Syntax
The syntax of conditionals.
* Testing Flags
Conditionals that test flags.
Functions for Transforming Text

* Syntax of Functions
How to write a function call.
* Text Functions
General-purpose text manipulation functions.
* Filename Functions
Functions for manipulating file names.
* Foreach Function
Repeat some text with controlled variation.
* Origin Function
Find where a variable got its value.
* Shell Function
Substitute the output of a shell command.
How to Run `make'

* Makefile Arguments
How to specify which makefile to use.
* Goals
How to use goal arguments to specify which parts of the makefile to use.
* Instead of Execution
How to use mode flags to specify what kind of thing to do with the commands in the makefile other than simply execute them.
* Avoiding Compilation
How to avoid recompiling certain files.
* Overriding
How to override a variable to specify an alternate compiler and other things.
* Testing
How to proceed past some errors, to test compilation.
* Options Summary
Summary of Options
Using Implicit Rules

* Using Implicit
How to use an existing implicit rule to get the commands for updating a file.
* Catalogue of Rules
A list of built-in implicit rules.
* Implicit Variables
How to change what predefined rules do.
* Chained Rules
How to use a chain of implicit rules.
* Pattern Rules
How to define new implicit rules.
* Last Resort
How to defining commands for rules which cannot find any.
* Suffix Rules
The old-fashioned style of implicit rule.
* Search Algorithm
The precise algorithm for applying implicit rules.
Defining and Redefining Pattern Rules

* Pattern Intro
An introduction to pattern rules.
* Pattern Examples
Examples of pattern rules.
* Automatic
How to use automatic variables in the commands of implicit rules.
* Pattern Match
How patterns match.
* Match-Anything Rules
Precautions you should take prior to defining rules that can match any target file whatever.
* Canceling Rules
How to override or cancel built-in rules.
Using `make' to Update Archive Files

* Archive Members
Archive members as targets.
* Archive Update
The implicit rule for archive member targets.
* Archive Suffix Rules
You can write a special kind of suffix rule for updating archives.
Implicit Rule for Archive Member Targets

* Archive Symbols
How to update archive symbol directories.

automatically generated by info2www