From 49621cbaa079e5481700f2f8c615384d2a1db037 Mon Sep 17 00:00:00 2001 From: Lionel Sambuc Date: Sat, 25 Aug 2018 12:24:49 +0200 Subject: [PATCH] Remove gmake support for cross-compilation Change-Id: I41d5aec5e11df6c44438501b09f85c6ad5eba096 --- external/gpl2/Makefile | 27 - external/gpl2/gmake/fetch.sh | 31 - .../gpl2/gmake/patches/0000-gmake-nbsd.patch | 11980 ---------------- .../patches/0001-support-latest-glibc.patch | 36 - tools/gmake/Makefile | 18 - 5 files changed, 12092 deletions(-) delete mode 100644 external/gpl2/Makefile delete mode 100755 external/gpl2/gmake/fetch.sh delete mode 100644 external/gpl2/gmake/patches/0000-gmake-nbsd.patch delete mode 100644 external/gpl2/gmake/patches/0001-support-latest-glibc.patch delete mode 100644 tools/gmake/Makefile diff --git a/external/gpl2/Makefile b/external/gpl2/Makefile deleted file mode 100644 index 4e7fd64a3..000000000 --- a/external/gpl2/Makefile +++ /dev/null @@ -1,27 +0,0 @@ -# $NetBSD: Makefile,v 1.5 2009/04/08 17:24:55 christos Exp $ - -.include - -.if defined(__MINIX) && 0 -# LSC FIXME: Hackish way to trigger the fetch phase from here -# in the same way as from tools. -MODULE= gmake - -.include "${.CURDIR}/../../tools/Makefile.gnuhost" - -# Force the mapping to standard targets even when not building tools -# We considere work to be done as soon as the fetch step is done, -# as everything else has to be triggered from /tools or ../usr.bin - -.if ${USETOOLS} != "yes" -realall realinstall: ${GNUHOSTDIST:H}/.gitignore -.endif # defined(__MINIX) - -.if (${MKCVS} != "no") -SUBDIR+= xcvs -.endif -.if (${MKLVM} != "no") -SUBDIR+= lvm2 -.endif - -.include diff --git a/external/gpl2/gmake/fetch.sh b/external/gpl2/gmake/fetch.sh deleted file mode 100755 index a89293276..000000000 --- a/external/gpl2/gmake/fetch.sh +++ /dev/null @@ -1,31 +0,0 @@ -#!/bin/sh - -# Make sure we're in our directory (i.e., where this shell script is) -echo $0 -cd `dirname $0` - -FETCH=ftp -which curl >/dev/null -if [ $? -eq 0 ]; then - FETCH="curl -O -f" -fi - -# Configure fetch method - GMAKE -URL="http://www.minix3.org/pkgsrc/distfiles/minix/3.4.0/make-3.81.tar.bz2" -BACKUP_URL="ftp://ftp.gnu.org/gnu/make/make-3.81.tar.bz2" - -# Fetch sources if not available -if [ ! -d dist ]; -then - if [ ! -f make-3.81.tar.bz2 ]; then - $FETCH $URL - if [ $? -ne 0 ]; then - $FETCH $BACKUP_URL - fi - fi - - tar -xjf make-3.81.tar.bz2 && \ - mv make-3.81 dist && \ - cd dist && \ - cat ../patches/* | patch -p 1 || true -fi diff --git a/external/gpl2/gmake/patches/0000-gmake-nbsd.patch b/external/gpl2/gmake/patches/0000-gmake-nbsd.patch deleted file mode 100644 index cbccd9bb5..000000000 --- a/external/gpl2/gmake/patches/0000-gmake-nbsd.patch +++ /dev/null @@ -1,11980 +0,0 @@ -diff -rNU3 dist.orig/Makefile.in dist/Makefile.in ---- dist.orig/Makefile.in 2006-04-01 08:40:04.000000000 +0200 -+++ dist/Makefile.in 2014-08-18 08:57:25.000000000 +0200 -@@ -330,6 +330,8 @@ - am--refresh: - @: - $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) -+ @echo "NOT REBUILDING $@" -+NetBSD_DISABLED_Makefile.in: - @for dep in $?; do \ - case '$(am__configure_deps)' in \ - *$$dep*) \ -@@ -357,6 +359,8 @@ - $(SHELL) ./config.status --recheck - - $(top_srcdir)/configure: $(am__configure_deps) -+ @echo "NOT REBUILDING $@" -+NetBSD_DISABLED_configure: - cd $(srcdir) && $(AUTOCONF) - $(ACLOCAL_M4): $(am__aclocal_m4_deps) - cd $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS) -@@ -371,6 +375,8 @@ - @rm -f stamp-h1 - cd $(top_builddir) && $(SHELL) ./config.status config.h - $(srcdir)/config.h.in: $(am__configure_deps) -+ @echo "NOT REBUILDING $@" -+NetBSD_DISABLED_config.h.in: - cd $(top_srcdir) && $(AUTOHEADER) - rm -f stamp-h1 - touch $@ -diff -rNU3 dist.orig/ansi2knr.c dist/ansi2knr.c ---- dist.orig/ansi2knr.c 2006-04-01 08:40:04.000000000 +0200 -+++ dist/ansi2knr.c 2014-08-18 08:46:57.000000000 +0200 -@@ -1,6 +1,6 @@ - /* Copyright (C) 1989, 2000 Aladdin Enterprises. All rights reserved. */ - --/*$Id: ansi2knr.c,v 1.3 2000/04/13 03:41:48 lpd Exp $*/ -+/*$Id: ansi2knr.c,v 1.1.1.1 2014/08/18 06:46:57 christos Exp $*/ - /* Convert ANSI C function definitions to K&R ("traditional C") syntax */ - - /* -diff -rNU3 dist.orig/config/config.guess dist/config/config.guess ---- dist.orig/config/config.guess 2006-04-01 08:41:00.000000000 +0200 -+++ dist/config/config.guess 2014-08-18 09:12:47.000000000 +0200 -@@ -939,6 +939,9 @@ - sparc:Linux:*:* | sparc64:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu - exit ;; -+ tile*:Linux:*:*) -+ echo ${UNAME_MACHINE}-unknown-linux-gnu -+ exit 0 ;; - vax:Linux:*:*) - echo ${UNAME_MACHINE}-dec-linux-gnu - exit ;; -diff -rNU3 dist.orig/configure.in dist/configure.in ---- dist.orig/configure.in 2006-04-01 08:36:40.000000000 +0200 -+++ dist/configure.in 2014-08-18 08:46:47.000000000 +0200 -@@ -19,7 +19,7 @@ - AC_INIT([GNU make],[3.81],[bug-make@gnu.org]) - - AC_PREREQ(2.59) --AC_REVISION([[$Id: configure.in,v 1.142 2006/04/01 06:36:40 psmith Exp $]]) -+AC_REVISION([[$Id: configure.in,v 1.1.1.1 2014/08/18 06:46:47 christos Exp $]]) - - # Autoconf setup - AC_CONFIG_AUX_DIR(config) -diff -rNU3 dist.orig/doc/make.info dist/doc/make.info ---- dist.orig/doc/make.info 2006-04-01 08:41:04.000000000 +0200 -+++ dist/doc/make.info 1970-01-01 01:00:00.000000000 +0100 -@@ -1,184 +0,0 @@ --This is make.info, produced by makeinfo version 4.8 from make.texi. -- -- This file documents the GNU `make' utility, which determines --automatically which pieces of a large program need to be recompiled, --and issues the commands to recompile them. -- -- This is Edition 0.70, last updated 1 April 2006, of `The GNU Make --Manual', for GNU `make' version 3.81. -- -- Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, --1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006 Free Software --Foundation, Inc. -- -- Permission is granted to copy, distribute and/or modify this -- document under the terms of the GNU Free Documentation License, -- Version 1.2 or any later version published by the Free Software -- Foundation; with no Invariant Sections, with the Front-Cover Texts -- being "A GNU Manual," and with the Back-Cover Texts as in (a) -- below. A copy of the license is included in the section entitled -- "GNU Free Documentation License." -- -- (a) The FSF's Back-Cover Text is: "You have freedom to copy and -- modify this GNU Manual, like GNU software. Copies published by -- the Free Software Foundation raise funds for GNU development." -- --INFO-DIR-SECTION GNU Packages --START-INFO-DIR-ENTRY --* Make: (make). Remake files automatically. --END-INFO-DIR-ENTRY -- -- --Indirect: --make.info-1: 1297 --make.info-2: 301265 -- --Tag Table: --(Indirect) --Node: Top1297 --Node: Overview14702 --Node: Preparing15712 --Node: Reading16684 --Node: Bugs17611 --Node: Introduction19441 --Node: Rule Introduction21033 --Node: Simple Makefile22777 --Node: How Make Works26406 --Node: Variables Simplify29061 --Node: make Deduces31267 --Node: Combine By Prerequisite33007 --Node: Cleanup34036 --Node: Makefiles35455 --Node: Makefile Contents36421 --Node: Makefile Names39376 --Node: Include40987 --Ref: Include-Footnote-144619 --Node: MAKEFILES Variable44753 --Node: MAKEFILE_LIST Variable46263 --Node: Special Variables47531 --Node: Remaking Makefiles51038 --Node: Overriding Makefiles55287 --Node: Reading Makefiles57340 --Node: Secondary Expansion60244 --Node: Rules67678 --Node: Rule Example70350 --Node: Rule Syntax71207 --Node: Prerequisite Types73710 --Node: Wildcards75486 --Node: Wildcard Examples77204 --Node: Wildcard Pitfall78460 --Node: Wildcard Function80249 --Node: Directory Search82033 --Node: General Search83175 --Node: Selective Search84890 --Node: Search Algorithm87878 --Node: Commands/Search90397 --Node: Implicit/Search91743 --Node: Libraries/Search92687 --Node: Phony Targets94779 --Node: Force Targets99865 --Node: Empty Targets100910 --Node: Special Targets102208 --Node: Multiple Targets109382 --Node: Multiple Rules111257 --Node: Static Pattern113493 --Node: Static Usage114145 --Node: Static versus Implicit117866 --Node: Double-Colon119610 --Node: Automatic Prerequisites121267 --Node: Commands125545 --Node: Command Syntax126753 --Node: Splitting Lines128778 --Node: Variables in Commands131759 --Node: Echoing133086 --Node: Execution134378 --Ref: Execution-Footnote-1135629 --Node: Choosing the Shell135775 --Node: Parallel139744 --Node: Errors143337 --Node: Interrupts146983 --Node: Recursion148570 --Node: MAKE Variable150664 --Node: Variables/Recursion152931 --Node: Options/Recursion158372 --Node: -w Option163537 --Node: Sequences164532 --Node: Empty Commands167544 --Node: Using Variables168718 --Node: Reference171831 --Node: Flavors173390 --Node: Advanced179128 --Node: Substitution Refs179633 --Node: Computed Names181186 --Node: Values185730 --Node: Setting186643 --Node: Appending188679 --Node: Override Directive192605 --Node: Defining193989 --Node: Environment196453 --Node: Target-specific198702 --Node: Pattern-specific201669 --Node: Conditionals203071 --Node: Conditional Example203781 --Node: Conditional Syntax206358 --Node: Testing Flags212083 --Node: Functions213185 --Node: Syntax of Functions214605 --Node: Text Functions216804 --Node: File Name Functions225375 --Node: Conditional Functions230597 --Node: Foreach Function232971 --Node: Call Function236183 --Node: Value Function239068 --Node: Eval Function240505 --Node: Origin Function242779 --Node: Flavor Function245997 --Node: Shell Function247063 --Node: Make Control Functions248697 --Node: Running250366 --Node: Makefile Arguments252355 --Node: Goals253071 --Node: Instead of Execution257812 --Node: Avoiding Compilation261098 --Node: Overriding263073 --Node: Testing265371 --Node: Options Summary267256 --Node: Implicit Rules277382 --Node: Using Implicit279530 --Node: Catalogue of Rules283069 --Node: Implicit Variables292419 --Node: Chained Rules297254 --Node: Pattern Rules301265 --Node: Pattern Intro302801 --Node: Pattern Examples305698 --Node: Automatic Variables307507 --Node: Pattern Match314878 --Node: Match-Anything Rules316514 --Node: Canceling Rules320389 --Node: Last Resort321105 --Node: Suffix Rules322952 --Node: Implicit Rule Search326681 --Node: Archives330200 --Node: Archive Members330898 --Node: Archive Update332511 --Node: Archive Symbols334425 --Node: Archive Pitfalls335659 --Node: Archive Suffix Rules336382 --Node: Features337929 --Node: Missing346484 --Node: Makefile Conventions350222 --Node: Makefile Basics351008 --Node: Utilities in Makefiles354175 --Node: Command Variables356313 --Node: Directory Variables359883 --Node: Standard Targets374023 --Ref: Standard Targets-Footnote-1387142 --Node: Install Command Categories387242 --Node: Quick Reference391768 --Node: Error Messages402464 --Node: Complex Makefile410154 --Node: GNU Free Documentation License418872 --Node: Concept Index441321 --Node: Name Index506510 -- --End Tag Table -diff -rNU3 dist.orig/doc/make.info-1 dist/doc/make.info-1 ---- dist.orig/doc/make.info-1 2006-04-01 08:41:04.000000000 +0200 -+++ dist/doc/make.info-1 1970-01-01 01:00:00.000000000 +0100 -@@ -1,7261 +0,0 @@ --This is make.info, produced by makeinfo version 4.8 from make.texi. -- -- This file documents the GNU `make' utility, which determines --automatically which pieces of a large program need to be recompiled, --and issues the commands to recompile them. -- -- This is Edition 0.70, last updated 1 April 2006, of `The GNU Make --Manual', for GNU `make' version 3.81. -- -- Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, --1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006 Free Software --Foundation, Inc. -- -- Permission is granted to copy, distribute and/or modify this -- document under the terms of the GNU Free Documentation License, -- Version 1.2 or any later version published by the Free Software -- Foundation; with no Invariant Sections, with the Front-Cover Texts -- being "A GNU Manual," and with the Back-Cover Texts as in (a) -- below. A copy of the license is included in the section entitled -- "GNU Free Documentation License." -- -- (a) The FSF's Back-Cover Text is: "You have freedom to copy and -- modify this GNU Manual, like GNU software. Copies published by -- the Free Software Foundation raise funds for GNU development." -- --INFO-DIR-SECTION GNU Packages --START-INFO-DIR-ENTRY --* Make: (make). Remake files automatically. --END-INFO-DIR-ENTRY -- -- --File: make.info, Node: Top, Next: Overview, Prev: (dir), Up: (dir) -- --GNU `make' --********** -- --This file documents the GNU `make' utility, which determines --automatically which pieces of a large program need to be recompiled, --and issues the commands to recompile them. -- -- This is Edition 0.70, last updated 1 April 2006, of `The GNU Make --Manual', for GNU `make' version 3.81. -- -- Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, --1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006 Free Software --Foundation, Inc. -- -- Permission is granted to copy, distribute and/or modify this -- document under the terms of the GNU Free Documentation License, -- Version 1.2 or any later version published by the Free Software -- Foundation; with no Invariant Sections, with the Front-Cover Texts -- being "A GNU Manual," and with the Back-Cover Texts as in (a) -- below. A copy of the license is included in the section entitled -- "GNU Free Documentation License." -- -- (a) The FSF's Back-Cover Text is: "You have freedom to copy and -- modify this GNU Manual, like GNU software. Copies published by -- the Free Software Foundation raise funds for GNU development." -- --* Menu: -- --* 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. --* Invoking make: Running. How 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 writing makefiles for -- GNU programs. --* Quick Reference:: A quick reference for experienced users. --* Error Messages:: A list of common errors generated by `make'. --* Complex Makefile:: A real example of a straightforward, -- but nontrivial, makefile. -- --* GNU Free Documentation License:: License for copying this manual --* 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 Prerequisite:: 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. --* MAKEFILE_LIST Variable:: Discover which makefiles have been read. --* Special Variables:: Other special variables. --* Remaking Makefiles:: How makefiles get remade. --* Overriding Makefiles:: How to override part of one makefile -- with another makefile. --* Reading Makefiles:: How makefiles are parsed. --* Secondary Expansion:: How and when secondary expansion is performed. -- --Writing Rules -- --* Rule Example:: An example explained. --* Rule Syntax:: General syntax explained. --* Prerequisite Types:: There are two types of prerequisites. --* 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 prerequisites 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 prerequisites according to -- the target name. --* Double-Colon:: How to use a special kind of rule to allow -- several independent rules for one target. --* Automatic Prerequisites:: How to automatically generate rules giving -- prerequisites from 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 Prerequisites -- --* General Search:: Specifying a search path that applies -- to every prerequisite. --* Selective Search:: Specifying a search path -- for a specified class of names. --* Search Algorithm:: When and how search paths are applied. --* 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 -- --* Command Syntax:: Command syntax features and pitfalls. --* 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. -- --Command Syntax -- --* Splitting Lines:: Breaking long command lines for readability. --* Variables in Commands:: Using `make' variables in commands. -- --Command Execution -- --* Choosing the Shell:: How `make' chooses the shell used -- to run 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. --* Target-specific:: Variable values can be defined on a per-target -- basis. --* Pattern-specific:: Target-specific variable values can be applied -- to a group of targets that match a pattern. -- --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. --* File Name Functions:: Functions for manipulating file names. --* Conditional Functions:: Functions that implement conditions. --* Foreach Function:: Repeat some text with controlled variation. --* Call Function:: Expand a user-defined function. --* Value Function:: Return the un-expanded value of a variable. --* Eval Function:: Evaluate the arguments as makefile syntax. --* Origin Function:: Find where a variable got its value. --* Flavor Function:: Find out the flavor of a variable. --* Shell Function:: Substitute the output of a shell command. --* Make Control Functions:: Functions that control how make runs. -- --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 define commands for rules which -- cannot find any. --* Suffix Rules:: The old-fashioned style of implicit rule. --* Implicit Rule Search:: 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 Variables:: 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 Pitfalls:: Dangers to watch out for when using archives. --* 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. -- -- --File: make.info, Node: Overview, Next: Introduction, Prev: Top, Up: Top -- --1 Overview of `make' --******************** -- --The `make' utility automatically determines which pieces of a large --program need to be recompiled, and issues commands to recompile them. --This manual describes GNU `make', which was implemented by Richard --Stallman and Roland McGrath. Development since Version 3.76 has been --handled by Paul D. Smith. -- -- GNU `make' conforms to section 6.2 of `IEEE Standard 1003.2-1992' --(POSIX.2). -- -- Our examples show C programs, since they are most common, but you --can use `make' with any programming language whose compiler can be run --with a shell command. Indeed, `make' is not limited to programs. You --can use it to describe any task where some files must be updated --automatically from others whenever the others change. -- --* Menu: -- --* Preparing:: Preparing and Running Make --* Reading:: On Reading this Text --* Bugs:: Problems and Bugs -- -- --File: make.info, Node: Preparing, Next: Reading, Prev: Overview, Up: Overview -- --Preparing and Running Make --========================== -- -- To prepare to use `make', you must write a file called the --"makefile" that describes the relationships among files in your program --and provides commands for updating each file. In a program, typically, --the executable file is updated from object files, which are in turn --made by compiling source files. -- -- Once a suitable makefile exists, each time you change some source --files, this simple shell command: -- -- make -- --suffices to perform all necessary recompilations. The `make' program --uses the makefile data base and the last-modification times of the --files to decide which of the files need to be updated. For each of --those files, it issues the commands recorded in the data base. -- -- You can provide command line arguments to `make' to control which --files should be recompiled, or how. *Note How to Run `make': Running. -- -- --File: make.info, Node: Reading, Next: Bugs, Prev: Preparing, Up: Overview -- --1.1 How to Read This Manual --=========================== -- --If you are new to `make', or are looking for a general introduction, --read the first few sections of each chapter, skipping the later --sections. In each chapter, the first few sections contain introductory --or general information and the later sections contain specialized or --technical information. The exception is the second chapter, *Note An --Introduction to Makefiles: Introduction, all of which is introductory. -- -- If you are familiar with other `make' programs, see *Note Features --of GNU `make': Features, which lists the enhancements GNU `make' has, --and *Note Incompatibilities and Missing Features: Missing, which --explains the few things GNU `make' lacks that others have. -- -- For a quick summary, see *Note Options Summary::, *Note Quick --Reference::, and *Note Special Targets::. -- -- --File: make.info, Node: Bugs, Prev: Reading, Up: Overview -- --1.2 Problems and Bugs --===================== -- --If you have problems with GNU `make' or think you've found a bug, --please report it to the developers; we cannot promise to do anything but --we might well want to fix it. -- -- Before reporting a bug, make sure you've actually found a real bug. --Carefully reread the documentation and see if it really says you can do --what you're trying to do. If it's not clear whether you should be able --to do something or not, report that too; it's a bug in the --documentation! -- -- Before reporting a bug or trying to fix it yourself, try to isolate --it to the smallest possible makefile that reproduces the problem. Then --send us the makefile and the exact results `make' gave you, including --any error or warning messages. Please don't paraphrase these messages: --it's best to cut and paste them into your report. When generating this --small makefile, be sure to not use any non-free or unusual tools in --your commands: you can almost always emulate what such a tool would do --with simple shell commands. Finally, be sure to explain what you --expected to occur; this will help us decide whether the problem was --really in the documentation. -- -- Once you have a precise problem you can report it in one of two ways. --Either send electronic mail to: -- -- bug-make@gnu.org -- --or use our Web-based project management tool, at: -- -- http://savannah.gnu.org/projects/make/ -- --In addition to the information above, please be careful to include the --version number of `make' you are using. You can get this information --with the command `make --version'. Be sure also to include the type of --machine and operating system you are using. One way to obtain this --information is by looking at the final lines of output from the command --`make --help'. -- -- --File: make.info, Node: Introduction, Next: Makefiles, Prev: Overview, Up: Top -- --2 An Introduction to Makefiles --****************************** -- --You need a file called a "makefile" to tell `make' what to do. Most --often, the makefile tells `make' how to compile and link a program. -- -- In this chapter, we will discuss a simple makefile that describes --how to compile and link a text editor which consists of eight C source --files and three header files. The makefile can also tell `make' how to --run miscellaneous commands when explicitly asked (for example, to remove --certain files as a clean-up operation). To see a more complex example --of a makefile, see *Note Complex Makefile::. -- -- When `make' recompiles the editor, each changed C source file must --be recompiled. If a header file has changed, each C source file that --includes the header file must be recompiled to be safe. Each --compilation produces an object file corresponding to the source file. --Finally, if any source file has been recompiled, all the object files, --whether newly made or saved from previous compilations, must be linked --together to produce the new executable editor. -- --* Menu: -- --* 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 Prerequisite:: Another Style of Makefile --* Cleanup:: Rules for Cleaning the Directory -- -- --File: make.info, Node: Rule Introduction, Next: Simple Makefile, Prev: Introduction, Up: Introduction -- --2.1 What a Rule Looks Like --========================== -- --A simple makefile consists of "rules" with the following shape: -- -- TARGET ... : PREREQUISITES ... -- COMMAND -- ... -- ... -- -- A "target" is usually the name of a file that is generated by a --program; examples of targets are executable or object files. A target --can also be the name of an action to carry out, such as `clean' (*note --Phony Targets::). -- -- A "prerequisite" is a file that is used as input to create the --target. A target often depends on several files. -- -- A "command" is an action that `make' carries out. A rule may have --more than one command, each on its own line. *Please note:* you need --to put a tab character at the beginning of every command line! This is --an obscurity that catches the unwary. -- -- Usually a command is in a rule with prerequisites and serves to --create a target file if any of the prerequisites change. However, the --rule that specifies commands for the target need not have --prerequisites. For example, the rule containing the delete command --associated with the target `clean' does not have prerequisites. -- -- A "rule", then, explains how and when to remake certain files which --are the targets of the particular rule. `make' carries out the --commands on the prerequisites to create or update the target. A rule --can also explain how and when to carry out an action. *Note Writing --Rules: Rules. -- -- A makefile may contain other text besides rules, but a simple --makefile need only contain rules. Rules may look somewhat more --complicated than shown in this template, but all fit the pattern more --or less. -- -- --File: make.info, Node: Simple Makefile, Next: How Make Works, Prev: Rule Introduction, Up: Introduction -- --2.2 A Simple Makefile --===================== -- --Here is a straightforward makefile that describes the way an executable --file called `edit' depends on eight object files which, in turn, depend --on eight C source and three header files. -- -- In this example, all the C files include `defs.h', but only those --defining editing commands include `command.h', and only low level files --that change the editor buffer include `buffer.h'. -- -- edit : main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- cc -o edit main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- -- main.o : main.c defs.h -- cc -c main.c -- kbd.o : kbd.c defs.h command.h -- cc -c kbd.c -- command.o : command.c defs.h command.h -- cc -c command.c -- display.o : display.c defs.h buffer.h -- cc -c display.c -- insert.o : insert.c defs.h buffer.h -- cc -c insert.c -- search.o : search.c defs.h buffer.h -- cc -c search.c -- files.o : files.c defs.h buffer.h command.h -- cc -c files.c -- utils.o : utils.c defs.h -- cc -c utils.c -- clean : -- rm edit main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- --We split each long line into two lines using backslash-newline; this is --like using one long line, but is easier to read. -- -- To use this makefile to create the executable file called `edit', --type: -- -- make -- -- To use this makefile to delete the executable file and all the object --files from the directory, type: -- -- make clean -- -- In the example makefile, the targets include the executable file --`edit', and the object files `main.o' and `kbd.o'. The prerequisites --are files such as `main.c' and `defs.h'. In fact, each `.o' file is --both a target and a prerequisite. Commands include `cc -c main.c' and --`cc -c kbd.c'. -- -- When a target is a file, it needs to be recompiled or relinked if any --of its prerequisites change. In addition, any prerequisites that are --themselves automatically generated should be updated first. In this --example, `edit' depends on each of the eight object files; the object --file `main.o' depends on the source file `main.c' and on the header --file `defs.h'. -- -- A shell command follows each line that contains a target and --prerequisites. These shell commands say how to update the target file. --A tab character must come at the beginning of every command line to --distinguish command lines from other lines in the makefile. (Bear in --mind that `make' does not know anything about how the commands work. --It is up to you to supply commands that will update the target file --properly. All `make' does is execute the commands in the rule you have --specified when the target file needs to be updated.) -- -- The target `clean' is not a file, but merely the name of an action. --Since you normally do not want to carry out the actions in this rule, --`clean' is not a prerequisite of any other rule. Consequently, `make' --never does anything with it unless you tell it specifically. Note that --this rule not only is not a prerequisite, it also does not have any --prerequisites, so the only purpose of the rule is to run the specified --commands. Targets that do not refer to files but are just actions are --called "phony targets". *Note Phony Targets::, for information about --this kind of target. *Note Errors in Commands: Errors, to see how to --cause `make' to ignore errors from `rm' or any other command. -- -- --File: make.info, Node: How Make Works, Next: Variables Simplify, Prev: Simple Makefile, Up: Introduction -- --2.3 How `make' Processes a Makefile --=================================== -- --By default, `make' starts with the first target (not targets whose --names start with `.'). This is called the "default goal". ("Goals" --are the targets that `make' strives ultimately to update. You can --override this behavior using the command line (*note Arguments to --Specify the Goals: Goals.) or with the `.DEFAULT_GOAL' special variable --(*note Other Special Variables: Special Variables.). -- -- In the simple example of the previous section, the default goal is to --update the executable program `edit'; therefore, we put that rule first. -- -- Thus, when you give the command: -- -- make -- --`make' reads the makefile in the current directory and begins by --processing the first rule. In the example, this rule is for relinking --`edit'; but before `make' can fully process this rule, it must process --the rules for the files that `edit' depends on, which in this case are --the object files. Each of these files is processed according to its --own rule. These rules say to update each `.o' file by compiling its --source file. The recompilation must be done if the source file, or any --of the header files named as prerequisites, is more recent than the --object file, or if the object file does not exist. -- -- The other rules are processed because their targets appear as --prerequisites of the goal. If some other rule is not depended on by the --goal (or anything it depends on, etc.), that rule is not processed, --unless you tell `make' to do so (with a command such as `make clean'). -- -- Before recompiling an object file, `make' considers updating its --prerequisites, the source file and header files. This makefile does not --specify anything to be done for them--the `.c' and `.h' files are not --the targets of any rules--so `make' does nothing for these files. But --`make' would update automatically generated C programs, such as those --made by Bison or Yacc, by their own rules at this time. -- -- After recompiling whichever object files need it, `make' decides --whether to relink `edit'. This must be done if the file `edit' does --not exist, or if any of the object files are newer than it. If an --object file was just recompiled, it is now newer than `edit', so `edit' --is relinked. -- -- Thus, if we change the file `insert.c' and run `make', `make' will --compile that file to update `insert.o', and then link `edit'. If we --change the file `command.h' and run `make', `make' will recompile the --object files `kbd.o', `command.o' and `files.o' and then link the file --`edit'. -- -- --File: make.info, Node: Variables Simplify, Next: make Deduces, Prev: How Make Works, Up: Introduction -- --2.4 Variables Make Makefiles Simpler --==================================== -- --In our example, we had to list all the object files twice in the rule --for `edit' (repeated here): -- -- edit : main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- cc -o edit main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- -- Such duplication is error-prone; if a new object file is added to the --system, we might add it to one list and forget the other. We can --eliminate the risk and simplify the makefile by using a variable. --"Variables" allow a text string to be defined once and substituted in --multiple places later (*note How to Use Variables: Using Variables.). -- -- It is standard practice for every makefile to have a variable named --`objects', `OBJECTS', `objs', `OBJS', `obj', or `OBJ' which is a list --of all object file names. We would define such a variable `objects' --with a line like this in the makefile: -- -- objects = main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- --Then, each place we want to put a list of the object file names, we can --substitute the variable's value by writing `$(objects)' (*note How to --Use Variables: Using Variables.). -- -- Here is how the complete simple makefile looks when you use a --variable for the object files: -- -- objects = main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- -- edit : $(objects) -- cc -o edit $(objects) -- main.o : main.c defs.h -- cc -c main.c -- kbd.o : kbd.c defs.h command.h -- cc -c kbd.c -- command.o : command.c defs.h command.h -- cc -c command.c -- display.o : display.c defs.h buffer.h -- cc -c display.c -- insert.o : insert.c defs.h buffer.h -- cc -c insert.c -- search.o : search.c defs.h buffer.h -- cc -c search.c -- files.o : files.c defs.h buffer.h command.h -- cc -c files.c -- utils.o : utils.c defs.h -- cc -c utils.c -- clean : -- rm edit $(objects) -- -- --File: make.info, Node: make Deduces, Next: Combine By Prerequisite, Prev: Variables Simplify, Up: Introduction -- --2.5 Letting `make' Deduce the Commands --====================================== -- --It is not necessary to spell out the commands for compiling the --individual C source files, because `make' can figure them out: it has an --"implicit rule" for updating a `.o' file from a correspondingly named --`.c' file using a `cc -c' command. For example, it will use the --command `cc -c main.c -o main.o' to compile `main.c' into `main.o'. We --can therefore omit the commands from the rules for the object files. --*Note Using Implicit Rules: Implicit Rules. -- -- When a `.c' file is used automatically in this way, it is also --automatically added to the list of prerequisites. We can therefore omit --the `.c' files from the prerequisites, provided we omit the commands. -- -- Here is the entire example, with both of these changes, and a --variable `objects' as suggested above: -- -- objects = main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- -- edit : $(objects) -- cc -o edit $(objects) -- -- main.o : defs.h -- kbd.o : defs.h command.h -- command.o : defs.h command.h -- display.o : defs.h buffer.h -- insert.o : defs.h buffer.h -- search.o : defs.h buffer.h -- files.o : defs.h buffer.h command.h -- utils.o : defs.h -- -- .PHONY : clean -- clean : -- rm edit $(objects) -- --This is how we would write the makefile in actual practice. (The --complications associated with `clean' are described elsewhere. See --*Note Phony Targets::, and *Note Errors in Commands: Errors.) -- -- Because implicit rules are so convenient, they are important. You --will see them used frequently. -- -- --File: make.info, Node: Combine By Prerequisite, Next: Cleanup, Prev: make Deduces, Up: Introduction -- --2.6 Another Style of Makefile --============================= -- --When the objects of a makefile are created only by implicit rules, an --alternative style of makefile is possible. In this style of makefile, --you group entries by their prerequisites instead of by their targets. --Here is what one looks like: -- -- objects = main.o kbd.o command.o display.o \ -- insert.o search.o files.o utils.o -- -- edit : $(objects) -- cc -o edit $(objects) -- -- $(objects) : defs.h -- kbd.o command.o files.o : command.h -- display.o insert.o search.o files.o : buffer.h -- --Here `defs.h' is given as a prerequisite of all the object files; --`command.h' and `buffer.h' are prerequisites of the specific object --files listed for them. -- -- Whether this is better is a matter of taste: it is more compact, but --some people dislike it because they find it clearer to put all the --information about each target in one place. -- -- --File: make.info, Node: Cleanup, Prev: Combine By Prerequisite, Up: Introduction -- --2.7 Rules for Cleaning the Directory --==================================== -- --Compiling a program is not the only thing you might want to write rules --for. Makefiles commonly tell how to do a few other things besides --compiling a program: for example, how to delete all the object files --and executables so that the directory is `clean'. -- -- Here is how we could write a `make' rule for cleaning our example --editor: -- -- clean: -- rm edit $(objects) -- -- In practice, we might want to write the rule in a somewhat more --complicated manner to handle unanticipated situations. We would do --this: -- -- .PHONY : clean -- clean : -- -rm edit $(objects) -- --This prevents `make' from getting confused by an actual file called --`clean' and causes it to continue in spite of errors from `rm'. (See --*Note Phony Targets::, and *Note Errors in Commands: Errors.) -- --A rule such as this should not be placed at the beginning of the --makefile, because we do not want it to run by default! Thus, in the --example makefile, we want the rule for `edit', which recompiles the --editor, to remain the default goal. -- -- Since `clean' is not a prerequisite of `edit', this rule will not --run at all if we give the command `make' with no arguments. In order --to make the rule run, we have to type `make clean'. *Note How to Run --`make': Running. -- -- --File: make.info, Node: Makefiles, Next: Rules, Prev: Introduction, Up: Top -- --3 Writing Makefiles --******************* -- --The information that tells `make' how to recompile a system comes from --reading a data base called the "makefile". -- --* Menu: -- --* 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. --* MAKEFILE_LIST Variable:: Discover which makefiles have been read. --* Special Variables:: Other special variables. --* Remaking Makefiles:: How makefiles get remade. --* Overriding Makefiles:: How to override part of one makefile -- with another makefile. --* Reading Makefiles:: How makefiles are parsed. --* Secondary Expansion:: How and when secondary expansion is performed. -- -- --File: make.info, Node: Makefile Contents, Next: Makefile Names, Prev: Makefiles, Up: Makefiles -- --3.1 What Makefiles Contain --========================== -- --Makefiles contain five kinds of things: "explicit rules", "implicit --rules", "variable definitions", "directives", and "comments". Rules, --variables, and directives are described at length in later chapters. -- -- * An "explicit rule" says when and how to remake one or more files, -- called the rule's "targets". It lists the other files that the -- targets depend on, called the "prerequisites" of the target, and -- may also give commands to use to create or update the targets. -- *Note Writing Rules: Rules. -- -- * An "implicit rule" says when and how to remake a class of files -- based on their names. It describes how a target may depend on a -- file with a name similar to the target and gives commands to -- create or update such a target. *Note Using Implicit Rules: -- Implicit Rules. -- -- * A "variable definition" is a line that specifies a text string -- value for a variable that can be substituted into the text later. -- The simple makefile example shows a variable definition for -- `objects' as a list of all object files (*note Variables Make -- Makefiles Simpler: Variables Simplify.). -- -- * A "directive" is a command for `make' to do something special while -- reading the makefile. These include: -- -- * Reading another makefile (*note Including Other Makefiles: -- Include.). -- -- * Deciding (based on the values of variables) whether to use or -- ignore a part of the makefile (*note Conditional Parts of -- Makefiles: Conditionals.). -- -- * Defining a variable from a verbatim string containing -- multiple lines (*note Defining Variables Verbatim: Defining.). -- -- * `#' in a line of a makefile starts a "comment". It and the rest -- of the line are ignored, except that a trailing backslash not -- escaped by another backslash will continue the comment across -- multiple lines. A line containing just a comment (with perhaps -- spaces before it) is effectively blank, and is ignored. If you -- want a literal `#', escape it with a backslash (e.g., `\#'). -- Comments may appear on any line in the makefile, although they are -- treated specially in certain situations. -- -- Within a command script (if the line begins with a TAB character) -- the entire line is passed to the shell, just as with any other -- line that begins with a TAB. The shell decides how to interpret -- the text: whether or not this is a comment is up to the shell. -- -- Within a `define' directive, comments are not ignored during the -- definition of the variable, but rather kept intact in the value of -- the variable. When the variable is expanded they will either be -- treated as `make' comments or as command script text, depending on -- the context in which the variable is evaluated. -- -- --File: make.info, Node: Makefile Names, Next: Include, Prev: Makefile Contents, Up: Makefiles -- --3.2 What Name to Give Your Makefile --=================================== -- --By default, when `make' looks for the makefile, it tries the following --names, in order: `GNUmakefile', `makefile' and `Makefile'. -- -- Normally you should call your makefile either `makefile' or --`Makefile'. (We recommend `Makefile' because it appears prominently --near the beginning of a directory listing, right near other important --files such as `README'.) The first name checked, `GNUmakefile', is not --recommended for most makefiles. You should use this name if you have a --makefile that is specific to GNU `make', and will not be understood by --other versions of `make'. Other `make' programs look for `makefile' and --`Makefile', but not `GNUmakefile'. -- -- If `make' finds none of these names, it does not use any makefile. --Then you must specify a goal with a command argument, and `make' will --attempt to figure out how to remake it using only its built-in implicit --rules. *Note Using Implicit Rules: Implicit Rules. -- -- If you want to use a nonstandard name for your makefile, you can --specify the makefile name with the `-f' or `--file' option. The --arguments `-f NAME' or `--file=NAME' tell `make' to read the file NAME --as the makefile. If you use more than one `-f' or `--file' option, you --can specify several makefiles. All the makefiles are effectively --concatenated in the order specified. The default makefile names --`GNUmakefile', `makefile' and `Makefile' are not checked automatically --if you specify `-f' or `--file'. -- -- --File: make.info, Node: Include, Next: MAKEFILES Variable, Prev: Makefile Names, Up: Makefiles -- --3.3 Including Other Makefiles --============================= -- --The `include' directive tells `make' to suspend reading the current --makefile and read one or more other makefiles before continuing. The --directive is a line in the makefile that looks like this: -- -- include FILENAMES... -- --FILENAMES can contain shell file name patterns. If FILENAMES is empty, --nothing is included and no error is printed. -- -- Extra spaces are allowed and ignored at the beginning of the line, --but a tab is not allowed. (If the line begins with a tab, it will be --considered a command line.) Whitespace is required between `include' --and the file names, and between file names; extra whitespace is ignored --there and at the end of the directive. A comment starting with `#' is --allowed at the end of the line. If the file names contain any variable --or function references, they are expanded. *Note How to Use Variables: --Using Variables. -- -- For example, if you have three `.mk' files, `a.mk', `b.mk', and --`c.mk', and `$(bar)' expands to `bish bash', then the following --expression -- -- include foo *.mk $(bar) -- -- is equivalent to -- -- include foo a.mk b.mk c.mk bish bash -- -- When `make' processes an `include' directive, it suspends reading of --the containing makefile and reads from each listed file in turn. When --that is finished, `make' resumes reading the makefile in which the --directive appears. -- -- One occasion for using `include' directives is when several programs, --handled by individual makefiles in various directories, need to use a --common set of variable definitions (*note Setting Variables: Setting.) --or pattern rules (*note Defining and Redefining Pattern Rules: Pattern --Rules.). -- -- Another such occasion is when you want to generate prerequisites from --source files automatically; the prerequisites can be put in a file that --is included by the main makefile. This practice is generally cleaner --than that of somehow appending the prerequisites to the end of the main --makefile as has been traditionally done with other versions of `make'. --*Note Automatic Prerequisites::. -- -- If the specified name does not start with a slash, and the file is --not found in the current directory, several other directories are --searched. First, any directories you have specified with the `-I' or --`--include-dir' option are searched (*note Summary of Options: Options --Summary.). Then the following directories (if they exist) are --searched, in this order: `PREFIX/include' (normally `/usr/local/include' --(1)) `/usr/gnu/include', `/usr/local/include', `/usr/include'. -- -- If an included makefile cannot be found in any of these directories, --a warning message is generated, but it is not an immediately fatal --error; processing of the makefile containing the `include' continues. --Once it has finished reading makefiles, `make' will try to remake any --that are out of date or don't exist. *Note How Makefiles Are Remade: --Remaking Makefiles. Only after it has tried to find a way to remake a --makefile and failed, will `make' diagnose the missing makefile as a --fatal error. -- -- If you want `make' to simply ignore a makefile which does not exist --and cannot be remade, with no error message, use the `-include' --directive instead of `include', like this: -- -- -include FILENAMES... -- -- This acts like `include' in every way except that there is no error --(not even a warning) if any of the FILENAMES do not exist. For --compatibility with some other `make' implementations, `sinclude' is --another name for `-include'. -- -- ---------- Footnotes ---------- -- -- (1) GNU Make compiled for MS-DOS and MS-Windows behaves as if PREFIX --has been defined to be the root of the DJGPP tree hierarchy. -- -- --File: make.info, Node: MAKEFILES Variable, Next: MAKEFILE_LIST Variable, Prev: Include, Up: Makefiles -- --3.4 The Variable `MAKEFILES' --============================ -- --If the environment variable `MAKEFILES' is defined, `make' considers --its value as a list of names (separated by whitespace) of additional --makefiles to be read before the others. This works much like the --`include' directive: various directories are searched for those files --(*note Including Other Makefiles: Include.). In addition, the default --goal is never taken from one of these makefiles and it is not an error --if the files listed in `MAKEFILES' are not found. -- -- The main use of `MAKEFILES' is in communication between recursive --invocations of `make' (*note Recursive Use of `make': Recursion.). It --usually is not desirable to set the environment variable before a --top-level invocation of `make', because it is usually better not to --mess with a makefile from outside. However, if you are running `make' --without a specific makefile, a makefile in `MAKEFILES' can do useful --things to help the built-in implicit rules work better, such as --defining search paths (*note Directory Search::). -- -- Some users are tempted to set `MAKEFILES' in the environment --automatically on login, and program makefiles to expect this to be done. --This is a very bad idea, because such makefiles will fail to work if --run by anyone else. It is much better to write explicit `include' --directives in the makefiles. *Note Including Other Makefiles: Include. -- -- --File: make.info, Node: MAKEFILE_LIST Variable, Next: Special Variables, Prev: MAKEFILES Variable, Up: Makefiles -- --3.5 The Variable `MAKEFILE_LIST' --================================ -- --As `make' reads various makefiles, including any obtained from the --`MAKEFILES' variable, the command line, the default files, or from --`include' directives, their names will be automatically appended to the --`MAKEFILE_LIST' variable. They are added right before `make' begins to --parse them. -- -- This means that if the first thing a makefile does is examine the --last word in this variable, it will be the name of the current makefile. --Once the current makefile has used `include', however, the last word --will be the just-included makefile. -- -- If a makefile named `Makefile' has this content: -- -- name1 := $(lastword $(MAKEFILE_LIST)) -- -- include inc.mk -- -- name2 := $(lastword $(MAKEFILE_LIST)) -- -- all: -- @echo name1 = $(name1) -- @echo name2 = $(name2) -- --then you would expect to see this output: -- -- name1 = Makefile -- name2 = inc.mk -- -- *Note Text Functions::, for more information on the `word' and --`words' functions used above. *Note The Two Flavors of Variables: --Flavors, for more information on simply-expanded (`:=') variable --definitions. -- -- --File: make.info, Node: Special Variables, Next: Remaking Makefiles, Prev: MAKEFILE_LIST Variable, Up: Makefiles -- --3.6 Other Special Variables --=========================== -- --GNU `make' also supports other special variables. Unless otherwise --documented here, these values lose their special properties if they are --set by a makefile or on the command line. -- --`.DEFAULT_GOAL' -- Sets the default goal to be used if no targets were specified on -- the command line (*note Arguments to Specify the Goals: Goals.). -- The `.DEFAULT_GOAL' variable allows you to discover the current -- default goal, restart the default goal selection algorithm by -- clearing its value, or to explicitly set the default goal. The -- following example illustrates these cases: -- -- # Query the default goal. -- ifeq ($(.DEFAULT_GOAL),) -- $(warning no default goal is set) -- endif -- -- .PHONY: foo -- foo: ; @echo $@ -- -- $(warning default goal is $(.DEFAULT_GOAL)) -- -- # Reset the default goal. -- .DEFAULT_GOAL := -- -- .PHONY: bar -- bar: ; @echo $@ -- -- $(warning default goal is $(.DEFAULT_GOAL)) -- -- # Set our own. -- .DEFAULT_GOAL := foo -- -- This makefile prints: -- -- no default goal is set -- default goal is foo -- default goal is bar -- foo -- -- Note that assigning more than one target name to `.DEFAULT_GOAL' is -- illegal and will result in an error. -- --`MAKE_RESTARTS' -- This variable is set only if this instance of `make' has restarted -- (*note How Makefiles Are Remade: Remaking Makefiles.): it will -- contain the number of times this instance has restarted. Note -- this is not the same as recursion (counted by the `MAKELEVEL' -- variable). You should not set, modify, or export this variable. -- --`.VARIABLES' -- Expands to a list of the _names_ of all global variables defined -- so far. This includes variables which have empty values, as well -- as built-in variables (*note Variables Used by Implicit Rules: -- Implicit Variables.), but does not include any variables which are -- only defined in a target-specific context. Note that any value -- you assign to this variable will be ignored; it will always return -- its special value. -- --`.FEATURES' -- Expands to a list of special features supported by this version of -- `make'. Possible values include: -- -- `archives' -- Supports `ar' (archive) files using special filename syntax. -- *Note Using `make' to Update Archive Files: Archives. -- -- `check-symlink' -- Supports the `-L' (`--check-symlink-times') flag. *Note -- Summary of Options: Options Summary. -- -- `else-if' -- Supports "else if" non-nested conditionals. *Note Syntax of -- Conditionals: Conditional Syntax. -- -- `jobserver' -- Supports "job server" enhanced parallel builds. *Note -- Parallel Execution: Parallel. -- -- `second-expansion' -- Supports secondary expansion of prerequisite lists. -- -- `order-only' -- Supports order-only prerequisites. *Note Types of -- Prerequisites: Prerequisite Types. -- -- `target-specific' -- Supports target-specific and pattern-specific variable -- assignments. *Note Target-specific Variable Values: -- Target-specific. -- -- --`.INCLUDE_DIRS' -- Expands to a list of directories that `make' searches for included -- makefiles (*note Including Other Makefiles: Include.). -- -- -- --File: make.info, Node: Remaking Makefiles, Next: Overriding Makefiles, Prev: Special Variables, Up: Makefiles -- --3.7 How Makefiles Are Remade --============================ -- --Sometimes makefiles can be remade from other files, such as RCS or SCCS --files. If a makefile can be remade from other files, you probably want --`make' to get an up-to-date version of the makefile to read in. -- -- To this end, after reading in all makefiles, `make' will consider --each as a goal target and attempt to update it. If a makefile has a --rule which says how to update it (found either in that very makefile or --in another one) or if an implicit rule applies to it (*note Using --Implicit Rules: Implicit Rules.), it will be updated if necessary. --After all makefiles have been checked, if any have actually been --changed, `make' starts with a clean slate and reads all the makefiles --over again. (It will also attempt to update each of them over again, --but normally this will not change them again, since they are already up --to date.) -- -- If you know that one or more of your makefiles cannot be remade and --you want to keep `make' from performing an implicit rule search on --them, perhaps for efficiency reasons, you can use any normal method of --preventing implicit rule lookup to do so. For example, you can write an --explicit rule with the makefile as the target, and an empty command --string (*note Using Empty Commands: Empty Commands.). -- -- If the makefiles specify a double-colon rule to remake a file with --commands but no prerequisites, that file will always be remade (*note --Double-Colon::). In the case of makefiles, a makefile that has a --double-colon rule with commands but no prerequisites will be remade --every time `make' is run, and then again after `make' starts over and --reads the makefiles in again. This would cause an infinite loop: --`make' would constantly remake the makefile, and never do anything --else. So, to avoid this, `make' will *not* attempt to remake makefiles --which are specified as targets of a double-colon rule with commands but --no prerequisites. -- -- If you do not specify any makefiles to be read with `-f' or `--file' --options, `make' will try the default makefile names; *note What Name to --Give Your Makefile: Makefile Names. Unlike makefiles explicitly --requested with `-f' or `--file' options, `make' is not certain that --these makefiles should exist. However, if a default makefile does not --exist but can be created by running `make' rules, you probably want the --rules to be run so that the makefile can be used. -- -- Therefore, if none of the default makefiles exists, `make' will try --to make each of them in the same order in which they are searched for --(*note What Name to Give Your Makefile: Makefile Names.) until it --succeeds in making one, or it runs out of names to try. Note that it --is not an error if `make' cannot find or make any makefile; a makefile --is not always necessary. -- -- When you use the `-t' or `--touch' option (*note Instead of --Executing the Commands: Instead of Execution.), you would not want to --use an out-of-date makefile to decide which targets to touch. So the --`-t' option has no effect on updating makefiles; they are really --updated even if `-t' is specified. Likewise, `-q' (or `--question') --and `-n' (or `--just-print') do not prevent updating of makefiles, --because an out-of-date makefile would result in the wrong output for --other targets. Thus, `make -f mfile -n foo' will update `mfile', read --it in, and then print the commands to update `foo' and its prerequisites --without running them. The commands printed for `foo' will be those --specified in the updated contents of `mfile'. -- -- However, on occasion you might actually wish to prevent updating of --even the makefiles. You can do this by specifying the makefiles as --goals in the command line as well as specifying them as makefiles. --When the makefile name is specified explicitly as a goal, the options --`-t' and so on do apply to them. -- -- Thus, `make -f mfile -n mfile foo' would read the makefile `mfile', --print the commands needed to update it without actually running them, --and then print the commands needed to update `foo' without running --them. The commands for `foo' will be those specified by the existing --contents of `mfile'. -- -- --File: make.info, Node: Overriding Makefiles, Next: Reading Makefiles, Prev: Remaking Makefiles, Up: Makefiles -- --3.8 Overriding Part of Another Makefile --======================================= -- --Sometimes it is useful to have a makefile that is mostly just like --another makefile. You can often use the `include' directive to include --one in the other, and add more targets or variable definitions. --However, if the two makefiles give different commands for the same --target, `make' will not let you just do this. But there is another way. -- -- In the containing makefile (the one that wants to include the other), --you can use a match-anything pattern rule to say that to remake any --target that cannot be made from the information in the containing --makefile, `make' should look in another makefile. *Note Pattern --Rules::, for more information on pattern rules. -- -- For example, if you have a makefile called `Makefile' that says how --to make the target `foo' (and other targets), you can write a makefile --called `GNUmakefile' that contains: -- -- foo: -- frobnicate > foo -- -- %: force -- @$(MAKE) -f Makefile $@ -- force: ; -- -- If you say `make foo', `make' will find `GNUmakefile', read it, and --see that to make `foo', it needs to run the command `frobnicate > foo'. --If you say `make bar', `make' will find no way to make `bar' in --`GNUmakefile', so it will use the commands from the pattern rule: `make ---f Makefile bar'. If `Makefile' provides a rule for updating `bar', --`make' will apply the rule. And likewise for any other target that --`GNUmakefile' does not say how to make. -- -- The way this works is that the pattern rule has a pattern of just --`%', so it matches any target whatever. The rule specifies a --prerequisite `force', to guarantee that the commands will be run even --if the target file already exists. We give `force' target empty --commands to prevent `make' from searching for an implicit rule to build --it--otherwise it would apply the same match-anything rule to `force' --itself and create a prerequisite loop! -- -- --File: make.info, Node: Reading Makefiles, Next: Secondary Expansion, Prev: Overriding Makefiles, Up: Makefiles -- --3.9 How `make' Reads a Makefile --=============================== -- --GNU `make' does its work in two distinct phases. During the first --phase it reads all the makefiles, included makefiles, etc. and --internalizes all the variables and their values, implicit and explicit --rules, and constructs a dependency graph of all the targets and their --prerequisites. During the second phase, `make' uses these internal --structures to determine what targets will need to be rebuilt and to --invoke the rules necessary to do so. -- -- It's important to understand this two-phase approach because it has a --direct impact on how variable and function expansion happens; this is --often a source of some confusion when writing makefiles. Here we will --present a summary of the phases in which expansion happens for different --constructs within the makefile. We say that expansion is "immediate" --if it happens during the first phase: in this case `make' will expand --any variables or functions in that section of a construct as the --makefile is parsed. We say that expansion is "deferred" if expansion --is not performed immediately. Expansion of deferred construct is not --performed until either the construct appears later in an immediate --context, or until the second phase. -- -- You may not be familiar with some of these constructs yet. You can --reference this section as you become familiar with them, in later --chapters. -- --Variable Assignment --------------------- -- --Variable definitions are parsed as follows: -- -- IMMEDIATE = DEFERRED -- IMMEDIATE ?= DEFERRED -- IMMEDIATE := IMMEDIATE -- IMMEDIATE += DEFERRED or IMMEDIATE -- -- define IMMEDIATE -- DEFERRED -- endef -- -- For the append operator, `+=', the right-hand side is considered --immediate if the variable was previously set as a simple variable --(`:='), and deferred otherwise. -- --Conditional Statements ------------------------ -- --All instances of conditional syntax are parsed immediately, in their --entirety; this includes the `ifdef', `ifeq', `ifndef', and `ifneq' --forms. Of course this means that automatic variables cannot be used in --conditional statements, as automatic variables are not set until the --command script for that rule is invoked. If you need to use automatic --variables in a conditional you _must_ use shell conditional syntax, in --your command script proper, for these tests, not `make' conditionals. -- --Rule Definition ----------------- -- --A rule is always expanded the same way, regardless of the form: -- -- IMMEDIATE : IMMEDIATE ; DEFERRED -- DEFERRED -- -- That is, the target and prerequisite sections are expanded --immediately, and the commands used to construct the target are always --deferred. This general rule is true for explicit rules, pattern rules, --suffix rules, static pattern rules, and simple prerequisite definitions. -- -- --File: make.info, Node: Secondary Expansion, Prev: Reading Makefiles, Up: Makefiles -- --3.10 Secondary Expansion --======================== -- --In the previous section we learned that GNU `make' works in two --distinct phases: a read-in phase and a target-update phase (*note How --`make' Reads a Makefile: Reading Makefiles.). GNU make also has the --ability to enable a _second expansion_ of the prerequisites (only) for --some or all targets defined in the makefile. In order for this second --expansion to occur, the special target `.SECONDEXPANSION' must be --defined before the first prerequisite list that makes use of this --feature. -- -- If that special target is defined then in between the two phases --mentioned above, right at the end of the read-in phase, all the --prerequisites of the targets defined after the special target are --expanded a _second time_. In most circumstances this secondary --expansion will have no effect, since all variable and function --references will have been expanded during the initial parsing of the --makefiles. In order to take advantage of the secondary expansion phase --of the parser, then, it's necessary to _escape_ the variable or --function reference in the makefile. In this case the first expansion --merely un-escapes the reference but doesn't expand it, and expansion is --left to the secondary expansion phase. For example, consider this --makefile: -- -- .SECONDEXPANSION: -- ONEVAR = onefile -- TWOVAR = twofile -- myfile: $(ONEVAR) $$(TWOVAR) -- -- After the first expansion phase the prerequisites list of the --`myfile' target will be `onefile' and `$(TWOVAR)'; the first --(unescaped) variable reference to ONEVAR is expanded, while the second --(escaped) variable reference is simply unescaped, without being --recognized as a variable reference. Now during the secondary expansion --the first word is expanded again but since it contains no variable or --function references it remains the static value `onefile', while the --second word is now a normal reference to the variable TWOVAR, which is --expanded to the value `twofile'. The final result is that there are --two prerequisites, `onefile' and `twofile'. -- -- Obviously, this is not a very interesting case since the same result --could more easily have been achieved simply by having both variables --appear, unescaped, in the prerequisites list. One difference becomes --apparent if the variables are reset; consider this example: -- -- .SECONDEXPANSION: -- AVAR = top -- onefile: $(AVAR) -- twofile: $$(AVAR) -- AVAR = bottom -- -- Here the prerequisite of `onefile' will be expanded immediately, and --resolve to the value `top', while the prerequisite of `twofile' will --not be full expanded until the secondary expansion and yield a value of --`bottom'. -- -- This is marginally more exciting, but the true power of this feature --only becomes apparent when you discover that secondary expansions --always take place within the scope of the automatic variables for that --target. This means that you can use variables such as `$@', `$*', etc. --during the second expansion and they will have their expected values, --just as in the command script. All you have to do is defer the --expansion by escaping the `$'. Also, secondary expansion occurs for --both explicit and implicit (pattern) rules. Knowing this, the possible --uses for this feature increase dramatically. For example: -- -- .SECONDEXPANSION: -- main_OBJS := main.o try.o test.o -- lib_OBJS := lib.o api.o -- -- main lib: $$($$@_OBJS) -- -- Here, after the initial expansion the prerequisites of both the --`main' and `lib' targets will be `$($@_OBJS)'. During the secondary --expansion, the `$@' variable is set to the name of the target and so --the expansion for the `main' target will yield `$(main_OBJS)', or --`main.o try.o test.o', while the secondary expansion for the `lib' --target will yield `$(lib_OBJS)', or `lib.o api.o'. -- -- You can also mix functions here, as long as they are properly --escaped: -- -- main_SRCS := main.c try.c test.c -- lib_SRCS := lib.c api.c -- -- .SECONDEXPANSION: -- main lib: $$(patsubst %.c,%.o,$$($$@_SRCS)) -- -- This version allows users to specify source files rather than object --files, but gives the same resulting prerequisites list as the previous --example. -- -- Evaluation of automatic variables during the secondary expansion --phase, especially of the target name variable `$$@', behaves similarly --to evaluation within command scripts. However, there are some subtle --differences and "corner cases" which come into play for the different --types of rule definitions that `make' understands. The subtleties of --using the different automatic variables are described below. -- --Secondary Expansion of Explicit Rules --------------------------------------- -- --During the secondary expansion of explicit rules, `$$@' and `$$%' --evaluate, respectively, to the file name of the target and, when the --target is an archive member, the target member name. The `$$<' --variable evaluates to the first prerequisite in the first rule for this --target. `$$^' and `$$+' evaluate to the list of all prerequisites of --rules _that have already appeared_ for the same target (`$$+' with --repetitions and `$$^' without). The following example will help --illustrate these behaviors: -- -- .SECONDEXPANSION: -- -- foo: foo.1 bar.1 $$< $$^ $$+ # line #1 -- -- foo: foo.2 bar.2 $$< $$^ $$+ # line #2 -- -- foo: foo.3 bar.3 $$< $$^ $$+ # line #3 -- -- In the first prerequisite list, all three variables (`$$<', `$$^', --and `$$+') expand to the empty string. In the second, they will have --values `foo.1', `foo.1 bar.1', and `foo.1 bar.1' respectively. In the --third they will have values `foo.1', `foo.1 bar.1 foo.2 bar.2', and --`foo.1 bar.1 foo.2 bar.2' respectively. -- -- Rules undergo secondary expansion in makefile order, except that the --rule with the command script is always evaluated last. -- -- The variables `$$?' and `$$*' are not available and expand to the --empty string. -- --Secondary Expansion of Static Pattern Rules --------------------------------------------- -- --Rules for secondary expansion of static pattern rules are identical to --those for explicit rules, above, with one exception: for static pattern --rules the `$$*' variable is set to the pattern stem. As with explicit --rules, `$$?' is not available and expands to the empty string. -- --Secondary Expansion of Implicit Rules --------------------------------------- -- --As `make' searches for an implicit rule, it substitutes the stem and --then performs secondary expansion for every rule with a matching target --pattern. The value of the automatic variables is derived in the same --fashion as for static pattern rules. As an example: -- -- .SECONDEXPANSION: -- -- foo: bar -- -- foo foz: fo%: bo% -- -- %oo: $$< $$^ $$+ $$* -- -- When the implicit rule is tried for target `foo', `$$<' expands to --`bar', `$$^' expands to `bar boo', `$$+' also expands to `bar boo', and --`$$*' expands to `f'. -- -- Note that the directory prefix (D), as described in *Note Implicit --Rule Search Algorithm: Implicit Rule Search, is appended (after --expansion) to all the patterns in the prerequisites list. As an --example: -- -- .SECONDEXPANSION: -- -- /tmp/foo.o: -- -- %.o: $$(addsuffix /%.c,foo bar) foo.h -- -- The prerequisite list after the secondary expansion and directory --prefix reconstruction will be `/tmp/foo/foo.c /tmp/var/bar/foo.c --foo.h'. If you are not interested in this reconstruction, you can use --`$$*' instead of `%' in the prerequisites list. -- -- --File: make.info, Node: Rules, Next: Commands, Prev: Makefiles, Up: Top -- --4 Writing Rules --*************** -- --A "rule" appears in the makefile and says when and how to remake --certain files, called the rule's "targets" (most often only one per --rule). It lists the other files that are the "prerequisites" of the --target, and "commands" to use to create or update the target. -- -- The order of rules is not significant, except for determining the --"default goal": the target for `make' to consider, if you do not --otherwise specify one. The default goal is the target of the first --rule in the first makefile. If the first rule has multiple targets, --only the first target is taken as the default. There are two --exceptions: a target starting with a period is not a default unless it --contains one or more slashes, `/', as well; and, a target that defines --a pattern rule has no effect on the default goal. (*Note Defining and --Redefining Pattern Rules: Pattern Rules.) -- -- Therefore, we usually write the makefile so that the first rule is --the one for compiling the entire program or all the programs described --by the makefile (often with a target called `all'). *Note Arguments to --Specify the Goals: Goals. -- --* Menu: -- --* Rule Example:: An example explained. --* Rule Syntax:: General syntax explained. --* Prerequisite Types:: There are two types of prerequisites. --* 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 prerequisites 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 prerequisites according to -- the target name. --* Double-Colon:: How to use a special kind of rule to allow -- several independent rules for one target. --* Automatic Prerequisites:: How to automatically generate rules giving -- prerequisites from source files themselves. -- -- --File: make.info, Node: Rule Example, Next: Rule Syntax, Prev: Rules, Up: Rules -- --4.1 Rule Example --================ -- --Here is an example of a rule: -- -- foo.o : foo.c defs.h # module for twiddling the frobs -- cc -c -g foo.c -- -- Its target is `foo.o' and its prerequisites are `foo.c' and --`defs.h'. It has one command, which is `cc -c -g foo.c'. The command --line starts with a tab to identify it as a command. -- -- This rule says two things: -- -- * How to decide whether `foo.o' is out of date: it is out of date if -- it does not exist, or if either `foo.c' or `defs.h' is more recent -- than it. -- -- * How to update the file `foo.o': by running `cc' as stated. The -- command does not explicitly mention `defs.h', but we presume that -- `foo.c' includes it, and that that is why `defs.h' was added to -- the prerequisites. -- -- --File: make.info, Node: Rule Syntax, Next: Prerequisite Types, Prev: Rule Example, Up: Rules -- --4.2 Rule Syntax --=============== -- --In general, a rule looks like this: -- -- TARGETS : PREREQUISITES -- COMMAND -- ... -- --or like this: -- -- TARGETS : PREREQUISITES ; COMMAND -- COMMAND -- ... -- -- The TARGETS are file names, separated by spaces. Wildcard --characters may be used (*note Using Wildcard Characters in File Names: --Wildcards.) and a name of the form `A(M)' represents member M in --archive file A (*note Archive Members as Targets: Archive Members.). --Usually there is only one target per rule, but occasionally there is a --reason to have more (*note Multiple Targets in a Rule: Multiple --Targets.). -- -- The COMMAND lines start with a tab character. The first command may --appear on the line after the prerequisites, with a tab character, or may --appear on the same line, with a semicolon. Either way, the effect is --the same. There are other differences in the syntax of command lines. --*Note Writing the Commands in Rules: Commands. -- -- Because dollar signs are used to start `make' variable references, --if you really want a dollar sign in a target or prerequisite you must --write two of them, `$$' (*note How to Use Variables: Using Variables.). --If you have enabled secondary expansion (*note Secondary Expansion::) --and you want a literal dollar sign in the prerequisites lise, you must --actually write _four_ dollar signs (`$$$$'). -- -- You may split a long line by inserting a backslash followed by a --newline, but this is not required, as `make' places no limit on the --length of a line in a makefile. -- -- A rule tells `make' two things: when the targets are out of date, --and how to update them when necessary. -- -- The criterion for being out of date is specified in terms of the --PREREQUISITES, which consist of file names separated by spaces. --(Wildcards and archive members (*note Archives::) are allowed here too.) --A target is out of date if it does not exist or if it is older than any --of the prerequisites (by comparison of last-modification times). The --idea is that the contents of the target file are computed based on --information in the prerequisites, so if any of the prerequisites --changes, the contents of the existing target file are no longer --necessarily valid. -- -- How to update is specified by COMMANDS. These are lines to be --executed by the shell (normally `sh'), but with some extra features --(*note Writing the Commands in Rules: Commands.). -- -- --File: make.info, Node: Prerequisite Types, Next: Wildcards, Prev: Rule Syntax, Up: Rules -- --4.3 Types of Prerequisites --========================== -- --There are actually two different types of prerequisites understood by --GNU `make': normal prerequisites such as described in the previous --section, and "order-only" prerequisites. A normal prerequisite makes --two statements: first, it imposes an order of execution of build --commands: any commands necessary to build any of a target's --prerequisites will be fully executed before any commands necessary to --build the target. Second, it imposes a dependency relationship: if any --prerequisite is newer than the target, then the target is considered --out-of-date and must be rebuilt. -- -- Normally, this is exactly what you want: if a target's prerequisite --is updated, then the target should also be updated. -- -- Occasionally, however, you have a situation where you want to impose --a specific ordering on the rules to be invoked _without_ forcing the --target to be updated if one of those rules is executed. In that case, --you want to define "order-only" prerequisites. Order-only --prerequisites can be specified by placing a pipe symbol (`|') in the --prerequisites list: any prerequisites to the left of the pipe symbol --are normal; any prerequisites to the right are order-only: -- -- TARGETS : NORMAL-PREREQUISITES | ORDER-ONLY-PREREQUISITES -- -- The normal prerequisites section may of course be empty. Also, you --may still declare multiple lines of prerequisites for the same target: --they are appended appropriately. Note that if you declare the same --file to be both a normal and an order-only prerequisite, the normal --prerequisite takes precedence (since they are a strict superset of the --behavior of an order-only prerequisite). -- -- --File: make.info, Node: Wildcards, Next: Directory Search, Prev: Prerequisite Types, Up: Rules -- --4.4 Using Wildcard Characters in File Names --=========================================== -- --A single file name can specify many files using "wildcard characters". --The wildcard characters in `make' are `*', `?' and `[...]', the same as --in the Bourne shell. For example, `*.c' specifies a list of all the --files (in the working directory) whose names end in `.c'. -- -- The character `~' at the beginning of a file name also has special --significance. If alone, or followed by a slash, it represents your home --directory. For example `~/bin' expands to `/home/you/bin'. If the `~' --is followed by a word, the string represents the home directory of the --user named by that word. For example `~john/bin' expands to --`/home/john/bin'. On systems which don't have a home directory for --each user (such as MS-DOS or MS-Windows), this functionality can be --simulated by setting the environment variable HOME. -- -- Wildcard expansion is performed by `make' automatically in targets --and in prerequisites. In commands the shell is responsible for --wildcard expansion. In other contexts, wildcard expansion happens only --if you request it explicitly with the `wildcard' function. -- -- The special significance of a wildcard character can be turned off by --preceding it with a backslash. Thus, `foo\*bar' would refer to a --specific file whose name consists of `foo', an asterisk, and `bar'. -- --* Menu: -- --* Wildcard Examples:: Several examples --* Wildcard Pitfall:: Problems to avoid. --* Wildcard Function:: How to cause wildcard expansion where -- it does not normally take place. -- -- --File: make.info, Node: Wildcard Examples, Next: Wildcard Pitfall, Prev: Wildcards, Up: Wildcards -- --4.4.1 Wildcard Examples ------------------------- -- --Wildcards can be used in the commands of a rule, where they are expanded --by the shell. For example, here is a rule to delete all the object --files: -- -- clean: -- rm -f *.o -- -- Wildcards are also useful in the prerequisites of a rule. With the --following rule in the makefile, `make print' will print all the `.c' --files that have changed since the last time you printed them: -- -- print: *.c -- lpr -p $? -- touch print -- --This rule uses `print' as an empty target file; see *Note Empty Target --Files to Record Events: Empty Targets. (The automatic variable `$?' is --used to print only those files that have changed; see *Note Automatic --Variables::.) -- -- Wildcard expansion does not happen when you define a variable. --Thus, if you write this: -- -- objects = *.o -- --then the value of the variable `objects' is the actual string `*.o'. --However, if you use the value of `objects' in a target, prerequisite or --command, wildcard expansion will take place at that time. To set --`objects' to the expansion, instead use: -- -- objects := $(wildcard *.o) -- --*Note Wildcard Function::. -- -- --File: make.info, Node: Wildcard Pitfall, Next: Wildcard Function, Prev: Wildcard Examples, Up: Wildcards -- --4.4.2 Pitfalls of Using Wildcards ----------------------------------- -- --Now here is an example of a naive way of using wildcard expansion, that --does not do what you would intend. Suppose you would like to say that --the executable file `foo' is made from all the object files in the --directory, and you write this: -- -- objects = *.o -- -- foo : $(objects) -- cc -o foo $(CFLAGS) $(objects) -- --The value of `objects' is the actual string `*.o'. Wildcard expansion --happens in the rule for `foo', so that each _existing_ `.o' file --becomes a prerequisite of `foo' and will be recompiled if necessary. -- -- But what if you delete all the `.o' files? When a wildcard matches --no files, it is left as it is, so then `foo' will depend on the --oddly-named file `*.o'. Since no such file is likely to exist, `make' --will give you an error saying it cannot figure out how to make `*.o'. --This is not what you want! -- -- Actually it is possible to obtain the desired result with wildcard --expansion, but you need more sophisticated techniques, including the --`wildcard' function and string substitution. *Note The Function --`wildcard': Wildcard Function. -- -- Microsoft operating systems (MS-DOS and MS-Windows) use backslashes --to separate directories in pathnames, like so: -- -- c:\foo\bar\baz.c -- -- This is equivalent to the Unix-style `c:/foo/bar/baz.c' (the `c:' --part is the so-called drive letter). When `make' runs on these --systems, it supports backslashes as well as the Unix-style forward --slashes in pathnames. However, this support does _not_ include the --wildcard expansion, where backslash is a quote character. Therefore, --you _must_ use Unix-style slashes in these cases. -- -- --File: make.info, Node: Wildcard Function, Prev: Wildcard Pitfall, Up: Wildcards -- --4.4.3 The Function `wildcard' ------------------------------- -- --Wildcard expansion happens automatically in rules. But wildcard --expansion does not normally take place when a variable is set, or --inside the arguments of a function. If you want to do wildcard --expansion in such places, you need to use the `wildcard' function, like --this: -- -- $(wildcard PATTERN...) -- --This string, used anywhere in a makefile, is replaced by a --space-separated list of names of existing files that match one of the --given file name patterns. If no existing file name matches a pattern, --then that pattern is omitted from the output of the `wildcard' --function. Note that this is different from how unmatched wildcards --behave in rules, where they are used verbatim rather than ignored --(*note Wildcard Pitfall::). -- -- One use of the `wildcard' function is to get a list of all the C --source files in a directory, like this: -- -- $(wildcard *.c) -- -- We can change the list of C source files into a list of object files --by replacing the `.c' suffix with `.o' in the result, like this: -- -- $(patsubst %.c,%.o,$(wildcard *.c)) -- --(Here we have used another function, `patsubst'. *Note Functions for --String Substitution and Analysis: Text Functions.) -- -- Thus, a makefile to compile all C source files in the directory and --then link them together could be written as follows: -- -- objects := $(patsubst %.c,%.o,$(wildcard *.c)) -- -- foo : $(objects) -- cc -o foo $(objects) -- --(This takes advantage of the implicit rule for compiling C programs, so --there is no need to write explicit rules for compiling the files. --*Note The Two Flavors of Variables: Flavors, for an explanation of --`:=', which is a variant of `='.) -- -- --File: make.info, Node: Directory Search, Next: Phony Targets, Prev: Wildcards, Up: Rules -- --4.5 Searching Directories for Prerequisites --=========================================== -- --For large systems, it is often desirable to put sources in a separate --directory from the binaries. The "directory search" features of `make' --facilitate this by searching several directories automatically to find --a prerequisite. When you redistribute the files among directories, you --do not need to change the individual rules, just the search paths. -- --* Menu: -- --* General Search:: Specifying a search path that applies -- to every prerequisite. --* Selective Search:: Specifying a search path -- for a specified class of names. --* Search Algorithm:: When and how search paths are applied. --* 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. -- -- --File: make.info, Node: General Search, Next: Selective Search, Prev: Directory Search, Up: Directory Search -- --4.5.1 `VPATH': Search Path for All Prerequisites -------------------------------------------------- -- --The value of the `make' variable `VPATH' specifies a list of --directories that `make' should search. Most often, the directories are --expected to contain prerequisite files that are not in the current --directory; however, `make' uses `VPATH' as a search list for both --prerequisites and targets of rules. -- -- Thus, if a file that is listed as a target or prerequisite does not --exist in the current directory, `make' searches the directories listed --in `VPATH' for a file with that name. If a file is found in one of --them, that file may become the prerequisite (see below). Rules may then --specify the names of files in the prerequisite list as if they all --existed in the current directory. *Note Writing Shell Commands with --Directory Search: Commands/Search. -- -- In the `VPATH' variable, directory names are separated by colons or --blanks. The order in which directories are listed is the order followed --by `make' in its search. (On MS-DOS and MS-Windows, semi-colons are --used as separators of directory names in `VPATH', since the colon can --be used in the pathname itself, after the drive letter.) -- -- For example, -- -- VPATH = src:../headers -- --specifies a path containing two directories, `src' and `../headers', --which `make' searches in that order. -- -- With this value of `VPATH', the following rule, -- -- foo.o : foo.c -- --is interpreted as if it were written like this: -- -- foo.o : src/foo.c -- --assuming the file `foo.c' does not exist in the current directory but --is found in the directory `src'. -- -- --File: make.info, Node: Selective Search, Next: Search Algorithm, Prev: General Search, Up: Directory Search -- --4.5.2 The `vpath' Directive ----------------------------- -- --Similar to the `VPATH' variable, but more selective, is the `vpath' --directive (note lower case), which allows you to specify a search path --for a particular class of file names: those that match a particular --pattern. Thus you can supply certain search directories for one class --of file names and other directories (or none) for other file names. -- -- There are three forms of the `vpath' directive: -- --`vpath PATTERN DIRECTORIES' -- Specify the search path DIRECTORIES for file names that match -- PATTERN. -- -- The search path, DIRECTORIES, is a list of directories to be -- searched, separated by colons (semi-colons on MS-DOS and -- MS-Windows) or blanks, just like the search path used in the -- `VPATH' variable. -- --`vpath PATTERN' -- Clear out the search path associated with PATTERN. -- --`vpath' -- Clear all search paths previously specified with `vpath' -- directives. -- -- A `vpath' pattern is a string containing a `%' character. The --string must match the file name of a prerequisite that is being searched --for, the `%' character matching any sequence of zero or more characters --(as in pattern rules; *note Defining and Redefining Pattern Rules: --Pattern Rules.). For example, `%.h' matches files that end in `.h'. --(If there is no `%', the pattern must match the prerequisite exactly, --which is not useful very often.) -- -- `%' characters in a `vpath' directive's pattern can be quoted with --preceding backslashes (`\'). Backslashes that would otherwise quote --`%' characters can be quoted with more backslashes. Backslashes that --quote `%' characters or other backslashes are removed from the pattern --before it is compared to file names. Backslashes that are not in --danger of quoting `%' characters go unmolested. -- -- When a prerequisite fails to exist in the current directory, if the --PATTERN in a `vpath' directive matches the name of the prerequisite --file, then the DIRECTORIES in that directive are searched just like --(and before) the directories in the `VPATH' variable. -- -- For example, -- -- vpath %.h ../headers -- --tells `make' to look for any prerequisite whose name ends in `.h' in --the directory `../headers' if the file is not found in the current --directory. -- -- If several `vpath' patterns match the prerequisite file's name, then --`make' processes each matching `vpath' directive one by one, searching --all the directories mentioned in each directive. `make' handles --multiple `vpath' directives in the order in which they appear in the --makefile; multiple directives with the same pattern are independent of --each other. -- -- Thus, -- -- vpath %.c foo -- vpath % blish -- vpath %.c bar -- --will look for a file ending in `.c' in `foo', then `blish', then `bar', --while -- -- vpath %.c foo:bar -- vpath % blish -- --will look for a file ending in `.c' in `foo', then `bar', then `blish'. -- -- --File: make.info, Node: Search Algorithm, Next: Commands/Search, Prev: Selective Search, Up: Directory Search -- --4.5.3 How Directory Searches are Performed -------------------------------------------- -- --When a prerequisite is found through directory search, regardless of --type (general or selective), the pathname located may not be the one --that `make' actually provides you in the prerequisite list. Sometimes --the path discovered through directory search is thrown away. -- -- The algorithm `make' uses to decide whether to keep or abandon a --path found via directory search is as follows: -- -- 1. If a target file does not exist at the path specified in the -- makefile, directory search is performed. -- -- 2. If the directory search is successful, that path is kept and this -- file is tentatively stored as the target. -- -- 3. All prerequisites of this target are examined using this same -- method. -- -- 4. After processing the prerequisites, the target may or may not need -- to be rebuilt: -- -- a. If the target does _not_ need to be rebuilt, the path to the -- file found during directory search is used for any -- prerequisite lists which contain this target. In short, if -- `make' doesn't need to rebuild the target then you use the -- path found via directory search. -- -- b. If the target _does_ need to be rebuilt (is out-of-date), the -- pathname found during directory search is _thrown away_, and -- the target is rebuilt using the file name specified in the -- makefile. In short, if `make' must rebuild, then the target -- is rebuilt locally, not in the directory found via directory -- search. -- -- This algorithm may seem complex, but in practice it is quite often --exactly what you want. -- -- Other versions of `make' use a simpler algorithm: if the file does --not exist, and it is found via directory search, then that pathname is --always used whether or not the target needs to be built. Thus, if the --target is rebuilt it is created at the pathname discovered during --directory search. -- -- If, in fact, this is the behavior you want for some or all of your --directories, you can use the `GPATH' variable to indicate this to --`make'. -- -- `GPATH' has the same syntax and format as `VPATH' (that is, a space- --or colon-delimited list of pathnames). If an out-of-date target is --found by directory search in a directory that also appears in `GPATH', --then that pathname is not thrown away. The target is rebuilt using the --expanded path. -- -- --File: make.info, Node: Commands/Search, Next: Implicit/Search, Prev: Search Algorithm, Up: Directory Search -- --4.5.4 Writing Shell Commands with Directory Search ---------------------------------------------------- -- --When a prerequisite is found in another directory through directory --search, this cannot change the commands of the rule; they will execute --as written. Therefore, you must write the commands with care so that --they will look for the prerequisite in the directory where `make' finds --it. -- -- This is done with the "automatic variables" such as `$^' (*note --Automatic Variables::). For instance, the value of `$^' is a list of --all the prerequisites of the rule, including the names of the --directories in which they were found, and the value of `$@' is the --target. Thus: -- -- foo.o : foo.c -- cc -c $(CFLAGS) $^ -o $@ -- --(The variable `CFLAGS' exists so you can specify flags for C --compilation by implicit rules; we use it here for consistency so it will --affect all C compilations uniformly; *note Variables Used by Implicit --Rules: Implicit Variables.) -- -- Often the prerequisites include header files as well, which you do --not want to mention in the commands. The automatic variable `$<' is --just the first prerequisite: -- -- VPATH = src:../headers -- foo.o : foo.c defs.h hack.h -- cc -c $(CFLAGS) $< -o $@ -- -- --File: make.info, Node: Implicit/Search, Next: Libraries/Search, Prev: Commands/Search, Up: Directory Search -- --4.5.5 Directory Search and Implicit Rules ------------------------------------------- -- --The search through the directories specified in `VPATH' or with `vpath' --also happens during consideration of implicit rules (*note Using --Implicit Rules: Implicit Rules.). -- -- For example, when a file `foo.o' has no explicit rule, `make' --considers implicit rules, such as the built-in rule to compile `foo.c' --if that file exists. If such a file is lacking in the current --directory, the appropriate directories are searched for it. If `foo.c' --exists (or is mentioned in the makefile) in any of the directories, the --implicit rule for C compilation is applied. -- -- The commands of implicit rules normally use automatic variables as a --matter of necessity; consequently they will use the file names found by --directory search with no extra effort. -- -- --File: make.info, Node: Libraries/Search, Prev: Implicit/Search, Up: Directory Search -- --4.5.6 Directory Search for Link Libraries ------------------------------------------- -- --Directory search applies in a special way to libraries used with the --linker. This special feature comes into play when you write a --prerequisite whose name is of the form `-lNAME'. (You can tell --something strange is going on here because the prerequisite is normally --the name of a file, and the _file name_ of a library generally looks --like `libNAME.a', not like `-lNAME'.) -- -- When a prerequisite's name has the form `-lNAME', `make' handles it --specially by searching for the file `libNAME.so' in the current --directory, in directories specified by matching `vpath' search paths --and the `VPATH' search path, and then in the directories `/lib', --`/usr/lib', and `PREFIX/lib' (normally `/usr/local/lib', but --MS-DOS/MS-Windows versions of `make' behave as if PREFIX is defined to --be the root of the DJGPP installation tree). -- -- If that file is not found, then the file `libNAME.a' is searched --for, in the same directories as above. -- -- For example, if there is a `/usr/lib/libcurses.a' library on your --system (and no `/usr/lib/libcurses.so' file), then -- -- foo : foo.c -lcurses -- cc $^ -o $@ -- --would cause the command `cc foo.c /usr/lib/libcurses.a -o foo' to be --executed when `foo' is older than `foo.c' or than --`/usr/lib/libcurses.a'. -- -- Although the default set of files to be searched for is `libNAME.so' --and `libNAME.a', this is customizable via the `.LIBPATTERNS' variable. --Each word in the value of this variable is a pattern string. When a --prerequisite like `-lNAME' is seen, `make' will replace the percent in --each pattern in the list with NAME and perform the above directory --searches using that library filename. If no library is found, the next --word in the list will be used. -- -- The default value for `.LIBPATTERNS' is `lib%.so lib%.a', which --provides the default behavior described above. -- -- You can turn off link library expansion completely by setting this --variable to an empty value. -- -- --File: make.info, Node: Phony Targets, Next: Force Targets, Prev: Directory Search, Up: Rules -- --4.6 Phony Targets --================= -- --A phony target is one that is not really the name of a file. It is --just a name for some commands to be executed when you make an explicit --request. There are two reasons to use a phony target: to avoid a --conflict with a file of the same name, and to improve performance. -- -- If you write a rule whose commands will not create the target file, --the commands will be executed every time the target comes up for --remaking. Here is an example: -- -- clean: -- rm *.o temp -- --Because the `rm' command does not create a file named `clean', probably --no such file will ever exist. Therefore, the `rm' command will be --executed every time you say `make clean'. -- -- The phony target will cease to work if anything ever does create a --file named `clean' in this directory. Since it has no prerequisites, --the file `clean' would inevitably be considered up to date, and its --commands would not be executed. To avoid this problem, you can --explicitly declare the target to be phony, using the special target --`.PHONY' (*note Special Built-in Target Names: Special Targets.) as --follows: -- -- .PHONY : clean -- --Once this is done, `make clean' will run the commands regardless of --whether there is a file named `clean'. -- -- Since it knows that phony targets do not name actual files that --could be remade from other files, `make' skips the implicit rule search --for phony targets (*note Implicit Rules::). This is why declaring a --target phony is good for performance, even if you are not worried about --the actual file existing. -- -- Thus, you first write the line that states that `clean' is a phony --target, then you write the rule, like this: -- -- .PHONY: clean -- clean: -- rm *.o temp -- -- Another example of the usefulness of phony targets is in conjunction --with recursive invocations of `make' (for more information, see *Note --Recursive Use of `make': Recursion.). In this case the makefile will --often contain a variable which lists a number of subdirectories to be --built. One way to handle this is with one rule whose command is a --shell loop over the subdirectories, like this: -- -- SUBDIRS = foo bar baz -- -- subdirs: -- for dir in $(SUBDIRS); do \ -- $(MAKE) -C $$dir; \ -- done -- -- There are a few problems with this method, however. First, any error --detected in a submake is not noted by this rule, so it will continue to --build the rest of the directories even when one fails. This can be --overcome by adding shell commands to note the error and exit, but then --it will do so even if `make' is invoked with the `-k' option, which is --unfortunate. Second, and perhaps more importantly, you cannot take --advantage of `make''s ability to build targets in parallel (*note --Parallel Execution: Parallel.), since there is only one rule. -- -- By declaring the subdirectories as phony targets (you must do this as --the subdirectory obviously always exists; otherwise it won't be built) --you can remove these problems: -- -- SUBDIRS = foo bar baz -- -- .PHONY: subdirs $(SUBDIRS) -- -- subdirs: $(SUBDIRS) -- -- $(SUBDIRS): -- $(MAKE) -C $@ -- -- foo: baz -- -- Here we've also declared that the `foo' subdirectory cannot be built --until after the `baz' subdirectory is complete; this kind of --relationship declaration is particularly important when attempting --parallel builds. -- -- A phony target should not be a prerequisite of a real target file; --if it is, its commands are run every time `make' goes to update that --file. As long as a phony target is never a prerequisite of a real --target, the phony target commands will be executed only when the phony --target is a specified goal (*note Arguments to Specify the Goals: --Goals.). -- -- Phony targets can have prerequisites. When one directory contains --multiple programs, it is most convenient to describe all of the --programs in one makefile `./Makefile'. Since the target remade by --default will be the first one in the makefile, it is common to make --this a phony target named `all' and give it, as prerequisites, all the --individual programs. For example: -- -- all : prog1 prog2 prog3 -- .PHONY : all -- -- prog1 : prog1.o utils.o -- cc -o prog1 prog1.o utils.o -- -- prog2 : prog2.o -- cc -o prog2 prog2.o -- -- prog3 : prog3.o sort.o utils.o -- cc -o prog3 prog3.o sort.o utils.o -- --Now you can say just `make' to remake all three programs, or specify as --arguments the ones to remake (as in `make prog1 prog3'). Phoniness is --not inherited: the prerequisites of a phony target are not themselves --phony, unless explicitly declared to be so. -- -- When one phony target is a prerequisite of another, it serves as a --subroutine of the other. For example, here `make cleanall' will delete --the object files, the difference files, and the file `program': -- -- .PHONY: cleanall cleanobj cleandiff -- -- cleanall : cleanobj cleandiff -- rm program -- -- cleanobj : -- rm *.o -- -- cleandiff : -- rm *.diff -- -- --File: make.info, Node: Force Targets, Next: Empty Targets, Prev: Phony Targets, Up: Rules -- --4.7 Rules without Commands or Prerequisites --=========================================== -- --If a rule has no prerequisites or commands, and the target of the rule --is a nonexistent file, then `make' imagines this target to have been --updated whenever its rule is run. This implies that all targets --depending on this one will always have their commands run. -- -- An example will illustrate this: -- -- clean: FORCE -- rm $(objects) -- FORCE: -- -- Here the target `FORCE' satisfies the special conditions, so the --target `clean' that depends on it is forced to run its commands. There --is nothing special about the name `FORCE', but that is one name --commonly used this way. -- -- As you can see, using `FORCE' this way has the same results as using --`.PHONY: clean'. -- -- Using `.PHONY' is more explicit and more efficient. However, other --versions of `make' do not support `.PHONY'; thus `FORCE' appears in --many makefiles. *Note Phony Targets::. -- -- --File: make.info, Node: Empty Targets, Next: Special Targets, Prev: Force Targets, Up: Rules -- --4.8 Empty Target Files to Record Events --======================================= -- --The "empty target" is a variant of the phony target; it is used to hold --commands for an action that you request explicitly from time to time. --Unlike a phony target, this target file can really exist; but the file's --contents do not matter, and usually are empty. -- -- The purpose of the empty target file is to record, with its --last-modification time, when the rule's commands were last executed. It --does so because one of the commands is a `touch' command to update the --target file. -- -- The empty target file should have some prerequisites (otherwise it --doesn't make sense). When you ask to remake the empty target, the --commands are executed if any prerequisite is more recent than the --target; in other words, if a prerequisite has changed since the last --time you remade the target. Here is an example: -- -- print: foo.c bar.c -- lpr -p $? -- touch print -- --With this rule, `make print' will execute the `lpr' command if either --source file has changed since the last `make print'. The automatic --variable `$?' is used to print only those files that have changed --(*note Automatic Variables::). -- -- --File: make.info, Node: Special Targets, Next: Multiple Targets, Prev: Empty Targets, Up: Rules -- --4.9 Special Built-in Target Names --================================= -- --Certain names have special meanings if they appear as targets. -- --`.PHONY' -- The prerequisites of the special target `.PHONY' are considered to -- be phony targets. When it is time to consider such a target, -- `make' will run its commands unconditionally, regardless of -- whether a file with that name exists or what its last-modification -- time is. *Note Phony Targets: Phony Targets. -- --`.SUFFIXES' -- The prerequisites of the special target `.SUFFIXES' are the list -- of suffixes to be used in checking for suffix rules. *Note -- Old-Fashioned Suffix Rules: Suffix Rules. -- --`.DEFAULT' -- The commands specified for `.DEFAULT' are used for any target for -- which no rules are found (either explicit rules or implicit rules). -- *Note Last Resort::. If `.DEFAULT' commands are specified, every -- file mentioned as a prerequisite, but not as a target in a rule, -- will have these commands executed on its behalf. *Note Implicit -- Rule Search Algorithm: Implicit Rule Search. -- --`.PRECIOUS' -- The targets which `.PRECIOUS' depends on are given the following -- special treatment: if `make' is killed or interrupted during the -- execution of their commands, the target is not deleted. *Note -- Interrupting or Killing `make': Interrupts. Also, if the target -- is an intermediate file, it will not be deleted after it is no -- longer needed, as is normally done. *Note Chains of Implicit -- Rules: Chained Rules. In this latter respect it overlaps with the -- `.SECONDARY' special target. -- -- You can also list the target pattern of an implicit rule (such as -- `%.o') as a prerequisite file of the special target `.PRECIOUS' to -- preserve intermediate files created by rules whose target patterns -- match that file's name. -- --`.INTERMEDIATE' -- The targets which `.INTERMEDIATE' depends on are treated as -- intermediate files. *Note Chains of Implicit Rules: Chained Rules. -- `.INTERMEDIATE' with no prerequisites has no effect. -- --`.SECONDARY' -- The targets which `.SECONDARY' depends on are treated as -- intermediate files, except that they are never automatically -- deleted. *Note Chains of Implicit Rules: Chained Rules. -- -- `.SECONDARY' with no prerequisites causes all targets to be treated -- as secondary (i.e., no target is removed because it is considered -- intermediate). -- --`.SECONDEXPANSION' -- If `.SECONDEXPANSION' is mentioned as a target anywhere in the -- makefile, then all prerequisite lists defined _after_ it appears -- will be expanded a second time after all makefiles have been read -- in. *Note Secondary Expansion: Secondary Expansion. -- -- The prerequisites of the special target `.SUFFIXES' are the list -- of suffixes to be used in checking for suffix rules. *Note -- Old-Fashioned Suffix Rules: Suffix Rules. -- --`.DELETE_ON_ERROR' -- If `.DELETE_ON_ERROR' is mentioned as a target anywhere in the -- makefile, then `make' will delete the target of a rule if it has -- changed and its commands exit with a nonzero exit status, just as -- it does when it receives a signal. *Note Errors in Commands: -- Errors. -- --`.IGNORE' -- If you specify prerequisites for `.IGNORE', then `make' will -- ignore errors in execution of the commands run for those particular -- files. The commands for `.IGNORE' are not meaningful. -- -- If mentioned as a target with no prerequisites, `.IGNORE' says to -- ignore errors in execution of commands for all files. This usage -- of `.IGNORE' is supported only for historical compatibility. Since -- this affects every command in the makefile, it is not very useful; -- we recommend you use the more selective ways to ignore errors in -- specific commands. *Note Errors in Commands: Errors. -- --`.LOW_RESOLUTION_TIME' -- If you specify prerequisites for `.LOW_RESOLUTION_TIME', `make' -- assumes that these files are created by commands that generate low -- resolution time stamps. The commands for `.LOW_RESOLUTION_TIME' -- are not meaningful. -- -- The high resolution file time stamps of many modern hosts lessen -- the chance of `make' incorrectly concluding that a file is up to -- date. Unfortunately, these hosts provide no way to set a high -- resolution file time stamp, so commands like `cp -p' that -- explicitly set a file's time stamp must discard its subsecond -- part. If a file is created by such a command, you should list it -- as a prerequisite of `.LOW_RESOLUTION_TIME' so that `make' does -- not mistakenly conclude that the file is out of date. For example: -- -- .LOW_RESOLUTION_TIME: dst -- dst: src -- cp -p src dst -- -- Since `cp -p' discards the subsecond part of `src''s time stamp, -- `dst' is typically slightly older than `src' even when it is up to -- date. The `.LOW_RESOLUTION_TIME' line causes `make' to consider -- `dst' to be up to date if its time stamp is at the start of the -- same second that `src''s time stamp is in. -- -- Due to a limitation of the archive format, archive member time -- stamps are always low resolution. You need not list archive -- members as prerequisites of `.LOW_RESOLUTION_TIME', as `make' does -- this automatically. -- --`.SILENT' -- If you specify prerequisites for `.SILENT', then `make' will not -- print the commands to remake those particular files before -- executing them. The commands for `.SILENT' are not meaningful. -- -- If mentioned as a target with no prerequisites, `.SILENT' says not -- to print any commands before executing them. This usage of -- `.SILENT' is supported only for historical compatibility. We -- recommend you use the more selective ways to silence specific -- commands. *Note Command Echoing: Echoing. If you want to silence -- all commands for a particular run of `make', use the `-s' or -- `--silent' option (*note Options Summary::). -- --`.EXPORT_ALL_VARIABLES' -- Simply by being mentioned as a target, this tells `make' to export -- all variables to child processes by default. *Note Communicating -- Variables to a Sub-`make': Variables/Recursion. -- --`.NOTPARALLEL' -- If `.NOTPARALLEL' is mentioned as a target, then this invocation of -- `make' will be run serially, even if the `-j' option is given. -- Any recursively invoked `make' command will still be run in -- parallel (unless its makefile contains this target). Any -- prerequisites on this target are ignored. -- -- Any defined implicit rule suffix also counts as a special target if --it appears as a target, and so does the concatenation of two suffixes, --such as `.c.o'. These targets are suffix rules, an obsolete way of --defining implicit rules (but a way still widely used). In principle, --any target name could be special in this way if you break it in two and --add both pieces to the suffix list. In practice, suffixes normally --begin with `.', so these special target names also begin with `.'. --*Note Old-Fashioned Suffix Rules: Suffix Rules. -- -- --File: make.info, Node: Multiple Targets, Next: Multiple Rules, Prev: Special Targets, Up: Rules -- --4.10 Multiple Targets in a Rule --=============================== -- --A rule with multiple targets is equivalent to writing many rules, each --with one target, and all identical aside from that. The same commands --apply to all the targets, but their effects may vary because you can --substitute the actual target name into the command using `$@'. The --rule contributes the same prerequisites to all the targets also. -- -- This is useful in two cases. -- -- * You want just prerequisites, no commands. For example: -- -- kbd.o command.o files.o: command.h -- -- gives an additional prerequisite to each of the three object files -- mentioned. -- -- * Similar commands work for all the targets. The commands do not -- need to be absolutely identical, since the automatic variable `$@' -- can be used to substitute the particular target to be remade into -- the commands (*note Automatic Variables::). For example: -- -- bigoutput littleoutput : text.g -- generate text.g -$(subst output,,$@) > $@ -- -- is equivalent to -- -- bigoutput : text.g -- generate text.g -big > bigoutput -- littleoutput : text.g -- generate text.g -little > littleoutput -- -- Here we assume the hypothetical program `generate' makes two types -- of output, one if given `-big' and one if given `-little'. *Note -- Functions for String Substitution and Analysis: Text Functions, -- for an explanation of the `subst' function. -- -- Suppose you would like to vary the prerequisites according to the --target, much as the variable `$@' allows you to vary the commands. You --cannot do this with multiple targets in an ordinary rule, but you can --do it with a "static pattern rule". *Note Static Pattern Rules: Static --Pattern. -- -- --File: make.info, Node: Multiple Rules, Next: Static Pattern, Prev: Multiple Targets, Up: Rules -- --4.11 Multiple Rules for One Target --================================== -- --One file can be the target of several rules. All the prerequisites --mentioned in all the rules are merged into one list of prerequisites for --the target. If the target is older than any prerequisite from any rule, --the commands are executed. -- -- There can only be one set of commands to be executed for a file. If --more than one rule gives commands for the same file, `make' uses the --last set given and prints an error message. (As a special case, if the --file's name begins with a dot, no error message is printed. This odd --behavior is only for compatibility with other implementations of --`make'... you should avoid using it). Occasionally it is useful to --have the same target invoke multiple commands which are defined in --different parts of your makefile; you can use "double-colon rules" --(*note Double-Colon::) for this. -- -- An extra rule with just prerequisites can be used to give a few extra --prerequisites to many files at once. For example, makefiles often have --a variable, such as `objects', containing a list of all the compiler --output files in the system being made. An easy way to say that all of --them must be recompiled if `config.h' changes is to write the following: -- -- objects = foo.o bar.o -- foo.o : defs.h -- bar.o : defs.h test.h -- $(objects) : config.h -- -- This could be inserted or taken out without changing the rules that --really specify how to make the object files, making it a convenient --form to use if you wish to add the additional prerequisite --intermittently. -- -- Another wrinkle is that the additional prerequisites could be --specified with a variable that you set with a command argument to `make' --(*note Overriding Variables: Overriding.). For example, -- -- extradeps= -- $(objects) : $(extradeps) -- --means that the command `make extradeps=foo.h' will consider `foo.h' as --a prerequisite of each object file, but plain `make' will not. -- -- If none of the explicit rules for a target has commands, then `make' --searches for an applicable implicit rule to find some commands *note --Using Implicit Rules: Implicit Rules.). -- -- --File: make.info, Node: Static Pattern, Next: Double-Colon, Prev: Multiple Rules, Up: Rules -- --4.12 Static Pattern Rules --========================= -- --"Static pattern rules" are rules which specify multiple targets and --construct the prerequisite names for each target based on the target --name. They are more general than ordinary rules with multiple targets --because the targets do not have to have identical prerequisites. Their --prerequisites must be _analogous_, but not necessarily _identical_. -- --* Menu: -- --* Static Usage:: The syntax of static pattern rules. --* Static versus Implicit:: When are they better than implicit rules? -- -- --File: make.info, Node: Static Usage, Next: Static versus Implicit, Prev: Static Pattern, Up: Static Pattern -- --4.12.1 Syntax of Static Pattern Rules --------------------------------------- -- --Here is the syntax of a static pattern rule: -- -- TARGETS ...: TARGET-PATTERN: PREREQ-PATTERNS ... -- COMMANDS -- ... -- --The TARGETS list specifies the targets that the rule applies to. The --targets can contain wildcard characters, just like the targets of --ordinary rules (*note Using Wildcard Characters in File Names: --Wildcards.). -- -- The TARGET-PATTERN and PREREQ-PATTERNS say how to compute the --prerequisites of each target. Each target is matched against the --TARGET-PATTERN to extract a part of the target name, called the "stem". --This stem is substituted into each of the PREREQ-PATTERNS to make the --prerequisite names (one from each PREREQ-PATTERN). -- -- Each pattern normally contains the character `%' just once. When the --TARGET-PATTERN matches a target, the `%' can match any part of the --target name; this part is called the "stem". The rest of the pattern --must match exactly. For example, the target `foo.o' matches the --pattern `%.o', with `foo' as the stem. The targets `foo.c' and --`foo.out' do not match that pattern. -- -- The prerequisite names for each target are made by substituting the --stem for the `%' in each prerequisite pattern. For example, if one --prerequisite pattern is `%.c', then substitution of the stem `foo' --gives the prerequisite name `foo.c'. It is legitimate to write a --prerequisite pattern that does not contain `%'; then this prerequisite --is the same for all targets. -- -- `%' characters in pattern rules can be quoted with preceding --backslashes (`\'). Backslashes that would otherwise quote `%' --characters can be quoted with more backslashes. Backslashes that quote --`%' characters or other backslashes are removed from the pattern before --it is compared to file names or has a stem substituted into it. --Backslashes that are not in danger of quoting `%' characters go --unmolested. For example, the pattern `the\%weird\\%pattern\\' has --`the%weird\' preceding the operative `%' character, and `pattern\\' --following it. The final two backslashes are left alone because they --cannot affect any `%' character. -- -- Here is an example, which compiles each of `foo.o' and `bar.o' from --the corresponding `.c' file: -- -- objects = foo.o bar.o -- -- all: $(objects) -- -- $(objects): %.o: %.c -- $(CC) -c $(CFLAGS) $< -o $@ -- --Here `$<' is the automatic variable that holds the name of the --prerequisite and `$@' is the automatic variable that holds the name of --the target; see *Note Automatic Variables::. -- -- Each target specified must match the target pattern; a warning is --issued for each target that does not. If you have a list of files, --only some of which will match the pattern, you can use the `filter' --function to remove nonmatching file names (*note Functions for String --Substitution and Analysis: Text Functions.): -- -- files = foo.elc bar.o lose.o -- -- $(filter %.o,$(files)): %.o: %.c -- $(CC) -c $(CFLAGS) $< -o $@ -- $(filter %.elc,$(files)): %.elc: %.el -- emacs -f batch-byte-compile $< -- --In this example the result of `$(filter %.o,$(files))' is `bar.o --lose.o', and the first static pattern rule causes each of these object --files to be updated by compiling the corresponding C source file. The --result of `$(filter %.elc,$(files))' is `foo.elc', so that file is made --from `foo.el'. -- -- Another example shows how to use `$*' in static pattern rules: -- -- bigoutput littleoutput : %output : text.g -- generate text.g -$* > $@ -- --When the `generate' command is run, `$*' will expand to the stem, --either `big' or `little'. -- -- --File: make.info, Node: Static versus Implicit, Prev: Static Usage, Up: Static Pattern -- --4.12.2 Static Pattern Rules versus Implicit Rules --------------------------------------------------- -- --A static pattern rule has much in common with an implicit rule defined --as a pattern rule (*note Defining and Redefining Pattern Rules: Pattern --Rules.). Both have a pattern for the target and patterns for --constructing the names of prerequisites. The difference is in how --`make' decides _when_ the rule applies. -- -- An implicit rule _can_ apply to any target that matches its pattern, --but it _does_ apply only when the target has no commands otherwise --specified, and only when the prerequisites can be found. If more than --one implicit rule appears applicable, only one applies; the choice --depends on the order of rules. -- -- By contrast, a static pattern rule applies to the precise list of --targets that you specify in the rule. It cannot apply to any other --target and it invariably does apply to each of the targets specified. --If two conflicting rules apply, and both have commands, that's an error. -- -- The static pattern rule can be better than an implicit rule for these --reasons: -- -- * You may wish to override the usual implicit rule for a few files -- whose names cannot be categorized syntactically but can be given -- in an explicit list. -- -- * If you cannot be sure of the precise contents of the directories -- you are using, you may not be sure which other irrelevant files -- might lead `make' to use the wrong implicit rule. The choice -- might depend on the order in which the implicit rule search is -- done. With static pattern rules, there is no uncertainty: each -- rule applies to precisely the targets specified. -- -- --File: make.info, Node: Double-Colon, Next: Automatic Prerequisites, Prev: Static Pattern, Up: Rules -- --4.13 Double-Colon Rules --======================= -- --"Double-colon" rules are rules written with `::' instead of `:' after --the target names. They are handled differently from ordinary rules --when the same target appears in more than one rule. -- -- When a target appears in multiple rules, all the rules must be the --same type: all ordinary, or all double-colon. If they are --double-colon, each of them is independent of the others. Each --double-colon rule's commands are executed if the target is older than --any prerequisites of that rule. If there are no prerequisites for that --rule, its commands are always executed (even if the target already --exists). This can result in executing none, any, or all of the --double-colon rules. -- -- Double-colon rules with the same target are in fact completely --separate from one another. Each double-colon rule is processed --individually, just as rules with different targets are processed. -- -- The double-colon rules for a target are executed in the order they --appear in the makefile. However, the cases where double-colon rules --really make sense are those where the order of executing the commands --would not matter. -- -- Double-colon rules are somewhat obscure and not often very useful; --they provide a mechanism for cases in which the method used to update a --target differs depending on which prerequisite files caused the update, --and such cases are rare. -- -- Each double-colon rule should specify commands; if it does not, an --implicit rule will be used if one applies. *Note Using Implicit Rules: --Implicit Rules. -- -- --File: make.info, Node: Automatic Prerequisites, Prev: Double-Colon, Up: Rules -- --4.14 Generating Prerequisites Automatically --=========================================== -- --In the makefile for a program, many of the rules you need to write often --say only that some object file depends on some header file. For --example, if `main.c' uses `defs.h' via an `#include', you would write: -- -- main.o: defs.h -- --You need this rule so that `make' knows that it must remake `main.o' --whenever `defs.h' changes. You can see that for a large program you --would have to write dozens of such rules in your makefile. And, you --must always be very careful to update the makefile every time you add --or remove an `#include'. -- -- To avoid this hassle, most modern C compilers can write these rules --for you, by looking at the `#include' lines in the source files. --Usually this is done with the `-M' option to the compiler. For --example, the command: -- -- cc -M main.c -- --generates the output: -- -- main.o : main.c defs.h -- --Thus you no longer have to write all those rules yourself. The --compiler will do it for you. -- -- Note that such a prerequisite constitutes mentioning `main.o' in a --makefile, so it can never be considered an intermediate file by implicit --rule search. This means that `make' won't ever remove the file after --using it; *note Chains of Implicit Rules: Chained Rules. -- -- With old `make' programs, it was traditional practice to use this --compiler feature to generate prerequisites on demand with a command like --`make depend'. That command would create a file `depend' containing --all the automatically-generated prerequisites; then the makefile could --use `include' to read them in (*note Include::). -- -- In GNU `make', the feature of remaking makefiles makes this practice --obsolete--you need never tell `make' explicitly to regenerate the --prerequisites, because it always regenerates any makefile that is out --of date. *Note Remaking Makefiles::. -- -- The practice we recommend for automatic prerequisite generation is --to have one makefile corresponding to each source file. For each --source file `NAME.c' there is a makefile `NAME.d' which lists what --files the object file `NAME.o' depends on. That way only the source --files that have changed need to be rescanned to produce the new --prerequisites. -- -- Here is the pattern rule to generate a file of prerequisites (i.e., --a makefile) called `NAME.d' from a C source file called `NAME.c': -- -- %.d: %.c -- @set -e; rm -f $@; \ -- $(CC) -M $(CPPFLAGS) $< > $@.$$$$; \ -- sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \ -- rm -f $@.$$$$ -- --*Note Pattern Rules::, for information on defining pattern rules. The --`-e' flag to the shell causes it to exit immediately if the `$(CC)' --command (or any other command) fails (exits with a nonzero status). -- -- With the GNU C compiler, you may wish to use the `-MM' flag instead --of `-M'. This omits prerequisites on system header files. *Note --Options Controlling the Preprocessor: (gcc.info)Preprocessor Options, --for details. -- -- The purpose of the `sed' command is to translate (for example): -- -- main.o : main.c defs.h -- --into: -- -- main.o main.d : main.c defs.h -- --This makes each `.d' file depend on all the source and header files --that the corresponding `.o' file depends on. `make' then knows it must --regenerate the prerequisites whenever any of the source or header files --changes. -- -- Once you've defined the rule to remake the `.d' files, you then use --the `include' directive to read them all in. *Note Include::. For --example: -- -- sources = foo.c bar.c -- -- include $(sources:.c=.d) -- --(This example uses a substitution variable reference to translate the --list of source files `foo.c bar.c' into a list of prerequisite --makefiles, `foo.d bar.d'. *Note Substitution Refs::, for full --information on substitution references.) Since the `.d' files are --makefiles like any others, `make' will remake them as necessary with no --further work from you. *Note Remaking Makefiles::. -- -- Note that the `.d' files contain target definitions; you should be --sure to place the `include' directive _after_ the first, default goal --in your makefiles or run the risk of having a random object file become --the default goal. *Note How Make Works::. -- -- --File: make.info, Node: Commands, Next: Using Variables, Prev: Rules, Up: Top -- --5 Writing the Commands in Rules --******************************* -- --The commands of a rule consist of one or more shell command lines to be --executed, one at a time, in the order they appear. Typically, the --result of executing these commands is that the target of the rule is --brought up to date. -- -- Users use many different shell programs, but commands in makefiles --are always interpreted by `/bin/sh' unless the makefile specifies --otherwise. *Note Command Execution: Execution. -- --* Menu: -- --* Command Syntax:: Command syntax features and pitfalls. --* 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. -- -- --File: make.info, Node: Command Syntax, Next: Echoing, Prev: Commands, Up: Commands -- --5.1 Command Syntax --================== -- --Makefiles have the unusual property that there are really two distinct --syntaxes in one file. Most of the makefile uses `make' syntax (*note --Writing Makefiles: Makefiles.). However, commands are meant to be --interpreted by the shell and so they are written using shell syntax. --The `make' program does not try to understand shell syntax: it performs --only a very few specific translations on the content of the command --before handing it to the shell. -- -- Each command line must start with a tab, except that the first --command line may be attached to the target-and-prerequisites line with a --semicolon in between. _Any_ line in the makefile that begins with a --tab and appears in a "rule context" (that is, after a rule has been --started until another rule or variable definition) will be considered a --command line for that rule. Blank lines and lines of just comments may --appear among the command lines; they are ignored. -- -- Some consequences of these rules include: -- -- * A blank line that begins with a tab is not blank: it's an empty -- command (*note Empty Commands::). -- -- * A comment in a command line is not a `make' comment; it will be -- passed to the shell as-is. Whether the shell treats it as a -- comment or not depends on your shell. -- -- * A variable definition in a "rule context" which is indented by a -- tab as the first character on the line, will be considered a -- command line, not a `make' variable definition, and passed to the -- shell. -- -- * A conditional expression (`ifdef', `ifeq', etc. *note Syntax of -- Conditionals: Conditional Syntax.) in a "rule context" which is -- indented by a tab as the first character on the line, will be -- considered a command line and be passed to the shell. -- -- --* Menu: -- --* Splitting Lines:: Breaking long command lines for readability. --* Variables in Commands:: Using `make' variables in commands. -- -- --File: make.info, Node: Splitting Lines, Next: Variables in Commands, Prev: Command Syntax, Up: Command Syntax -- --5.1.1 Splitting Command Lines ------------------------------- -- --One of the few ways in which `make' does interpret command lines is --checking for a backslash just before the newline. As in normal --makefile syntax, a single command can be split into multiple lines in --the makefile by placing a backslash before each newline. A sequence of --lines like this is considered a single command, and one instance of the --shell will be invoked to run it. -- -- However, in contrast to how they are treated in other places in a --makefile, backslash-newline pairs are _not_ removed from the command. --Both the backslash and the newline characters are preserved and passed --to the shell. How the backslash-newline is interpreted depends on your --shell. If the first character of the next line after the --backslash-newline is a tab, then that tab (and only that tab) is --removed. Whitespace is never added to the command. -- -- For example, this makefile: -- -- all : -- @echo no\ -- space -- @echo no\ -- space -- @echo one \ -- space -- @echo one\ -- space -- --consists of four separate shell commands where the output is: -- -- nospace -- nospace -- one space -- one space -- -- As a more complex example, this makefile: -- -- all : ; @echo 'hello \ -- world' ; echo "hello \ -- world" -- --will run one shell with a command script of: -- -- echo 'hello \ -- world' ; echo "hello \ -- world" -- --which, according to shell quoting rules, will yield the following --output: -- -- hello \ -- world -- hello world -- --Notice how the backslash/newline pair was removed inside the string --quoted with double quotes (`"..."'), but not from the string quoted --with single quotes (`'...''). This is the way the default shell --(`/bin/sh') handles backslash/newline pairs. If you specify a --different shell in your makefiles it may treat them differently. -- -- Sometimes you want to split a long line inside of single quotes, but --you don't want the backslash-newline to appear in the quoted content. --This is often the case when passing scripts to languages such as Perl, --where extraneous backslashes inside the script can change its meaning --or even be a syntax error. One simple way of handling this is to place --the quoted string, or even the entire command, into a `make' variable --then use the variable in the command. In this situation the newline --quoting rules for makefiles will be used, and the backslash-newline --will be removed. If we rewrite our example above using this method: -- -- HELLO = 'hello \ -- world' -- -- all : ; @echo $(HELLO) -- --we will get output like this: -- -- hello world -- -- If you like, you can also use target-specific variables (*note --Target-specific Variable Values: Target-specific.) to obtain a tighter --correspondence between the variable and the command that uses it. -- -- --File: make.info, Node: Variables in Commands, Prev: Splitting Lines, Up: Command Syntax -- --5.1.2 Using Variables in Commands ----------------------------------- -- --The other way in which `make' processes commands is by expanding any --variable references in them (*note Basics of Variable References: --Reference.). This occurs after make has finished reading all the --makefiles and the target is determined to be out of date; so, the --commands for targets which are not rebuilt are never expanded. -- -- Variable and function references in commands have identical syntax --and semantics to references elsewhere in the makefile. They also have --the same quoting rules: if you want a dollar sign to appear in your --command, you must double it (`$$'). For shells like the default shell, --that use dollar signs to introduce variables, it's important to keep --clear in your mind whether the variable you want to reference is a --`make' variable (use a single dollar sign) or a shell variable (use two --dollar signs). For example: -- -- LIST = one two three -- all: -- for i in $(LIST); do \ -- echo $$i; \ -- done -- --results in the following command being passed to the shell: -- -- for i in one two three; do \ -- echo $i; \ -- done -- --which generates the expected result: -- -- one -- two -- three -- -- --File: make.info, Node: Echoing, Next: Execution, Prev: Command Syntax, Up: Commands -- --5.2 Command Echoing --=================== -- --Normally `make' prints each command line before it is executed. We --call this "echoing" because it gives the appearance that you are typing --the commands yourself. -- -- When a line starts with `@', the echoing of that line is suppressed. --The `@' is discarded before the command is passed to the shell. --Typically you would use this for a command whose only effect is to print --something, such as an `echo' command to indicate progress through the --makefile: -- -- @echo About to make distribution files -- -- When `make' is given the flag `-n' or `--just-print' it only echoes --commands, it won't execute them. *Note Summary of Options: Options --Summary. In this case and only this case, even the commands starting --with `@' are printed. This flag is useful for finding out which --commands `make' thinks are necessary without actually doing them. -- -- The `-s' or `--silent' flag to `make' prevents all echoing, as if --all commands started with `@'. A rule in the makefile for the special --target `.SILENT' without prerequisites has the same effect (*note --Special Built-in Target Names: Special Targets.). `.SILENT' is --essentially obsolete since `@' is more flexible. -- -- --File: make.info, Node: Execution, Next: Parallel, Prev: Echoing, Up: Commands -- --5.3 Command Execution --===================== -- --When it is time to execute commands to update a target, they are --executed by invoking a new subshell for each command line. (In --practice, `make' may take shortcuts that do not affect the results.) -- -- *Please note:* this implies that setting shell variables and --invoking shell commands such as `cd' that set a context local to each --process will not affect the following command lines.(1) If you want to --use `cd' to affect the next statement, put both statements in a single --command line. Then `make' will invoke one shell to run the entire --line, and the shell will execute the statements in sequence. For --example: -- -- foo : bar/lose -- cd $(@D) && gobble $(@F) > ../$@ -- --Here we use the shell AND operator (`&&') so that if the `cd' command --fails, the script will fail without trying to invoke the `gobble' --command in the wrong directory, which could cause problems (in this --case it would certainly cause `../foo' to be truncated, at least). -- --* Menu: -- --* Choosing the Shell:: How `make' chooses the shell used -- to run commands. -- -- ---------- Footnotes ---------- -- -- (1) On MS-DOS, the value of current working directory is *global*, so --changing it _will_ affect the following command lines on those systems. -- -- --File: make.info, Node: Choosing the Shell, Prev: Execution, Up: Execution -- --5.3.1 Choosing the Shell -------------------------- -- --The program used as the shell is taken from the variable `SHELL'. If --this variable is not set in your makefile, the program `/bin/sh' is --used as the shell. -- -- Unlike most variables, the variable `SHELL' is never set from the --environment. This is because the `SHELL' environment variable is used --to specify your personal choice of shell program for interactive use. --It would be very bad for personal choices like this to affect the --functioning of makefiles. *Note Variables from the Environment: --Environment. -- -- Furthermore, when you do set `SHELL' in your makefile that value is --_not_ exported in the environment to commands that `make' invokes. --Instead, the value inherited from the user's environment, if any, is --exported. You can override this behavior by explicitly exporting --`SHELL' (*note Communicating Variables to a Sub-`make': --Variables/Recursion.), forcing it to be passed in the environment to --commands. -- -- However, on MS-DOS and MS-Windows the value of `SHELL' in the --environment *is* used, since on those systems most users do not set --this variable, and therefore it is most likely set specifically to be --used by `make'. On MS-DOS, if the setting of `SHELL' is not suitable --for `make', you can set the variable `MAKESHELL' to the shell that --`make' should use; if set it will be used as the shell instead of the --value of `SHELL'. -- --Choosing a Shell in DOS and Windows --................................... -- --Choosing a shell in MS-DOS and MS-Windows is much more complex than on --other systems. -- -- On MS-DOS, if `SHELL' is not set, the value of the variable --`COMSPEC' (which is always set) is used instead. -- -- The processing of lines that set the variable `SHELL' in Makefiles --is different on MS-DOS. The stock shell, `command.com', is --ridiculously limited in its functionality and many users of `make' tend --to install a replacement shell. Therefore, on MS-DOS, `make' examines --the value of `SHELL', and changes its behavior based on whether it --points to a Unix-style or DOS-style shell. This allows reasonable --functionality even if `SHELL' points to `command.com'. -- -- If `SHELL' points to a Unix-style shell, `make' on MS-DOS --additionally checks whether that shell can indeed be found; if not, it --ignores the line that sets `SHELL'. In MS-DOS, GNU `make' searches for --the shell in the following places: -- -- 1. In the precise place pointed to by the value of `SHELL'. For -- example, if the makefile specifies `SHELL = /bin/sh', `make' will -- look in the directory `/bin' on the current drive. -- -- 2. In the current directory. -- -- 3. In each of the directories in the `PATH' variable, in order. -- -- -- In every directory it examines, `make' will first look for the --specific file (`sh' in the example above). If this is not found, it --will also look in that directory for that file with one of the known --extensions which identify executable files. For example `.exe', --`.com', `.bat', `.btm', `.sh', and some others. -- -- If any of these attempts is successful, the value of `SHELL' will be --set to the full pathname of the shell as found. However, if none of --these is found, the value of `SHELL' will not be changed, and thus the --line that sets it will be effectively ignored. This is so `make' will --only support features specific to a Unix-style shell if such a shell is --actually installed on the system where `make' runs. -- -- Note that this extended search for the shell is limited to the cases --where `SHELL' is set from the Makefile; if it is set in the environment --or command line, you are expected to set it to the full pathname of the --shell, exactly as things are on Unix. -- -- The effect of the above DOS-specific processing is that a Makefile --that contains `SHELL = /bin/sh' (as many Unix makefiles do), will work --on MS-DOS unaltered if you have e.g. `sh.exe' installed in some --directory along your `PATH'. -- -- --File: make.info, Node: Parallel, Next: Errors, Prev: Execution, Up: Commands -- --5.4 Parallel Execution --====================== -- --GNU `make' knows how to execute several commands at once. Normally, --`make' will execute only one command at a time, waiting for it to --finish before executing the next. However, the `-j' or `--jobs' option --tells `make' to execute many commands simultaneously. -- -- On MS-DOS, the `-j' option has no effect, since that system doesn't --support multi-processing. -- -- If the `-j' option is followed by an integer, this is the number of --commands to execute at once; this is called the number of "job slots". --If there is nothing looking like an integer after the `-j' option, --there is no limit on the number of job slots. The default number of job --slots is one, which means serial execution (one thing at a time). -- -- One unpleasant consequence of running several commands --simultaneously is that output generated by the commands appears --whenever each command sends it, so messages from different commands may --be interspersed. -- -- Another problem is that two processes cannot both take input from the --same device; so to make sure that only one command tries to take input --from the terminal at once, `make' will invalidate the standard input --streams of all but one running command. This means that attempting to --read from standard input will usually be a fatal error (a `Broken pipe' --signal) for most child processes if there are several. -- -- It is unpredictable which command will have a valid standard input --stream (which will come from the terminal, or wherever you redirect the --standard input of `make'). The first command run will always get it --first, and the first command started after that one finishes will get --it next, and so on. -- -- We will change how this aspect of `make' works if we find a better --alternative. In the mean time, you should not rely on any command using --standard input at all if you are using the parallel execution feature; --but if you are not using this feature, then standard input works --normally in all commands. -- -- Finally, handling recursive `make' invocations raises issues. For --more information on this, see *Note Communicating Options to a --Sub-`make': Options/Recursion. -- -- If a command fails (is killed by a signal or exits with a nonzero --status), and errors are not ignored for that command (*note Errors in --Commands: Errors.), the remaining command lines to remake the same --target will not be run. If a command fails and the `-k' or --`--keep-going' option was not given (*note Summary of Options: Options --Summary.), `make' aborts execution. If make terminates for any reason --(including a signal) with child processes running, it waits for them to --finish before actually exiting. -- -- When the system is heavily loaded, you will probably want to run --fewer jobs than when it is lightly loaded. You can use the `-l' option --to tell `make' to limit the number of jobs to run at once, based on the --load average. The `-l' or `--max-load' option is followed by a --floating-point number. For example, -- -- -l 2.5 -- --will not let `make' start more than one job if the load average is --above 2.5. The `-l' option with no following number removes the load --limit, if one was given with a previous `-l' option. -- -- More precisely, when `make' goes to start up a job, and it already --has at least one job running, it checks the current load average; if it --is not lower than the limit given with `-l', `make' waits until the load --average goes below that limit, or until all the other jobs finish. -- -- By default, there is no load limit. -- -- --File: make.info, Node: Errors, Next: Interrupts, Prev: Parallel, Up: Commands -- --5.5 Errors in Commands --====================== -- --After each shell command returns, `make' looks at its exit status. If --the command completed successfully, the next command line is executed --in a new shell; after the last command line is finished, the rule is --finished. -- -- If there is an error (the exit status is nonzero), `make' gives up on --the current rule, and perhaps on all rules. -- -- Sometimes the failure of a certain command does not indicate a --problem. For example, you may use the `mkdir' command to ensure that a --directory exists. If the directory already exists, `mkdir' will report --an error, but you probably want `make' to continue regardless. -- -- To ignore errors in a command line, write a `-' at the beginning of --the line's text (after the initial tab). The `-' is discarded before --the command is passed to the shell for execution. -- -- For example, -- -- clean: -- -rm -f *.o -- --This causes `rm' to continue even if it is unable to remove a file. -- -- When you run `make' with the `-i' or `--ignore-errors' flag, errors --are ignored in all commands of all rules. A rule in the makefile for --the special target `.IGNORE' has the same effect, if there are no --prerequisites. These ways of ignoring errors are obsolete because `-' --is more flexible. -- -- When errors are to be ignored, because of either a `-' or the `-i' --flag, `make' treats an error return just like success, except that it --prints out a message that tells you the status code the command exited --with, and says that the error has been ignored. -- -- When an error happens that `make' has not been told to ignore, it --implies that the current target cannot be correctly remade, and neither --can any other that depends on it either directly or indirectly. No --further commands will be executed for these targets, since their --preconditions have not been achieved. -- -- Normally `make' gives up immediately in this circumstance, returning --a nonzero status. However, if the `-k' or `--keep-going' flag is --specified, `make' continues to consider the other prerequisites of the --pending targets, remaking them if necessary, before it gives up and --returns nonzero status. For example, after an error in compiling one --object file, `make -k' will continue compiling other object files even --though it already knows that linking them will be impossible. *Note --Summary of Options: Options Summary. -- -- The usual behavior assumes that your purpose is to get the specified --targets up to date; once `make' learns that this is impossible, it --might as well report the failure immediately. The `-k' option says --that the real purpose is to test as many of the changes made in the --program as possible, perhaps to find several independent problems so --that you can correct them all before the next attempt to compile. This --is why Emacs' `compile' command passes the `-k' flag by default. -- -- Usually when a command fails, if it has changed the target file at --all, the file is corrupted and cannot be used--or at least it is not --completely updated. Yet the file's time stamp says that it is now up to --date, so the next time `make' runs, it will not try to update that --file. The situation is just the same as when the command is killed by a --signal; *note Interrupts::. So generally the right thing to do is to --delete the target file if the command fails after beginning to change --the file. `make' will do this if `.DELETE_ON_ERROR' appears as a --target. This is almost always what you want `make' to do, but it is --not historical practice; so for compatibility, you must explicitly --request it. -- -- --File: make.info, Node: Interrupts, Next: Recursion, Prev: Errors, Up: Commands -- --5.6 Interrupting or Killing `make' --================================== -- --If `make' gets a fatal signal while a command is executing, it may --delete the target file that the command was supposed to update. This is --done if the target file's last-modification time has changed since --`make' first checked it. -- -- The purpose of deleting the target is to make sure that it is remade --from scratch when `make' is next run. Why is this? Suppose you type --`Ctrl-c' while a compiler is running, and it has begun to write an --object file `foo.o'. The `Ctrl-c' kills the compiler, resulting in an --incomplete file whose last-modification time is newer than the source --file `foo.c'. But `make' also receives the `Ctrl-c' signal and deletes --this incomplete file. If `make' did not do this, the next invocation --of `make' would think that `foo.o' did not require updating--resulting --in a strange error message from the linker when it tries to link an --object file half of which is missing. -- -- You can prevent the deletion of a target file in this way by making --the special target `.PRECIOUS' depend on it. Before remaking a target, --`make' checks to see whether it appears on the prerequisites of --`.PRECIOUS', and thereby decides whether the target should be deleted --if a signal happens. Some reasons why you might do this are that the --target is updated in some atomic fashion, or exists only to record a --modification-time (its contents do not matter), or must exist at all --times to prevent other sorts of trouble. -- -- --File: make.info, Node: Recursion, Next: Sequences, Prev: Interrupts, Up: Commands -- --5.7 Recursive Use of `make' --=========================== -- --Recursive use of `make' means using `make' as a command in a makefile. --This technique is useful when you want separate makefiles for various --subsystems that compose a larger system. For example, suppose you have --a subdirectory `subdir' which has its own makefile, and you would like --the containing directory's makefile to run `make' on the subdirectory. --You can do it by writing this: -- -- subsystem: -- cd subdir && $(MAKE) -- --or, equivalently, this (*note Summary of Options: Options Summary.): -- -- subsystem: -- $(MAKE) -C subdir -- -- You can write recursive `make' commands just by copying this example, --but there are many things to know about how they work and why, and about --how the sub-`make' relates to the top-level `make'. You may also find --it useful to declare targets that invoke recursive `make' commands as --`.PHONY' (for more discussion on when this is useful, see *Note Phony --Targets::). -- -- For your convenience, when GNU `make' starts (after it has processed --any `-C' options) it sets the variable `CURDIR' to the pathname of the --current working directory. This value is never touched by `make' --again: in particular note that if you include files from other --directories the value of `CURDIR' does not change. The value has the --same precedence it would have if it were set in the makefile (by --default, an environment variable `CURDIR' will not override this --value). Note that setting this variable has no impact on the operation --of `make' (it does not cause `make' to change its working directory, --for example). -- --* Menu: -- --* 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. -- -- --File: make.info, Node: MAKE Variable, Next: Variables/Recursion, Prev: Recursion, Up: Recursion -- --5.7.1 How the `MAKE' Variable Works ------------------------------------- -- --Recursive `make' commands should always use the variable `MAKE', not --the explicit command name `make', as shown here: -- -- subsystem: -- cd subdir && $(MAKE) -- -- The value of this variable is the file name with which `make' was --invoked. If this file name was `/bin/make', then the command executed --is `cd subdir && /bin/make'. If you use a special version of `make' to --run the top-level makefile, the same special version will be executed --for recursive invocations. -- -- As a special feature, using the variable `MAKE' in the commands of a --rule alters the effects of the `-t' (`--touch'), `-n' (`--just-print'), --or `-q' (`--question') option. Using the `MAKE' variable has the same --effect as using a `+' character at the beginning of the command line. --*Note Instead of Executing the Commands: Instead of Execution. This --special feature is only enabled if the `MAKE' variable appears directly --in the command script: it does not apply if the `MAKE' variable is --referenced through expansion of another variable. In the latter case --you must use the `+' token to get these special effects. -- -- Consider the command `make -t' in the above example. (The `-t' --option marks targets as up to date without actually running any --commands; see *Note Instead of Execution::.) Following the usual --definition of `-t', a `make -t' command in the example would create a --file named `subsystem' and do nothing else. What you really want it to --do is run `cd subdir && make -t'; but that would require executing the --command, and `-t' says not to execute commands. -- -- The special feature makes this do what you want: whenever a command --line of a rule contains the variable `MAKE', the flags `-t', `-n' and --`-q' do not apply to that line. Command lines containing `MAKE' are --executed normally despite the presence of a flag that causes most --commands not to be run. The usual `MAKEFLAGS' mechanism passes the --flags to the sub-`make' (*note Communicating Options to a Sub-`make': --Options/Recursion.), so your request to touch the files, or print the --commands, is propagated to the subsystem. -- -- --File: make.info, Node: Variables/Recursion, Next: Options/Recursion, Prev: MAKE Variable, Up: Recursion -- --5.7.2 Communicating Variables to a Sub-`make' ----------------------------------------------- -- --Variable values of the top-level `make' can be passed to the sub-`make' --through the environment by explicit request. These variables are --defined in the sub-`make' as defaults, but do not override what is --specified in the makefile used by the sub-`make' makefile unless you --use the `-e' switch (*note Summary of Options: Options Summary.). -- -- To pass down, or "export", a variable, `make' adds the variable and --its value to the environment for running each command. The sub-`make', --in turn, uses the environment to initialize its table of variable --values. *Note Variables from the Environment: Environment. -- -- Except by explicit request, `make' exports a variable only if it is --either defined in the environment initially or set on the command line, --and if its name consists only of letters, numbers, and underscores. --Some shells cannot cope with environment variable names consisting of --characters other than letters, numbers, and underscores. -- -- The value of the `make' variable `SHELL' is not exported. Instead, --the value of the `SHELL' variable from the invoking environment is --passed to the sub-`make'. You can force `make' to export its value for --`SHELL' by using the `export' directive, described below. *Note --Choosing the Shell::. -- -- The special variable `MAKEFLAGS' is always exported (unless you --unexport it). `MAKEFILES' is exported if you set it to anything. -- -- `make' automatically passes down variable values that were defined --on the command line, by putting them in the `MAKEFLAGS' variable. --*Note Options/Recursion::. -- -- Variables are _not_ normally passed down if they were created by --default by `make' (*note Variables Used by Implicit Rules: Implicit --Variables.). The sub-`make' will define these for itself. -- -- If you want to export specific variables to a sub-`make', use the --`export' directive, like this: -- -- export VARIABLE ... -- --If you want to _prevent_ a variable from being exported, use the --`unexport' directive, like this: -- -- unexport VARIABLE ... -- --In both of these forms, the arguments to `export' and `unexport' are --expanded, and so could be variables or functions which expand to a --(list of) variable names to be (un)exported. -- -- As a convenience, you can define a variable and export it at the same --time by doing: -- -- export VARIABLE = value -- --has the same result as: -- -- VARIABLE = value -- export VARIABLE -- --and -- -- export VARIABLE := value -- --has the same result as: -- -- VARIABLE := value -- export VARIABLE -- -- Likewise, -- -- export VARIABLE += value -- --is just like: -- -- VARIABLE += value -- export VARIABLE -- --*Note Appending More Text to Variables: Appending. -- -- You may notice that the `export' and `unexport' directives work in --`make' in the same way they work in the shell, `sh'. -- -- If you want all variables to be exported by default, you can use --`export' by itself: -- -- export -- --This tells `make' that variables which are not explicitly mentioned in --an `export' or `unexport' directive should be exported. Any variable --given in an `unexport' directive will still _not_ be exported. If you --use `export' by itself to export variables by default, variables whose --names contain characters other than alphanumerics and underscores will --not be exported unless specifically mentioned in an `export' directive. -- -- The behavior elicited by an `export' directive by itself was the --default in older versions of GNU `make'. If your makefiles depend on --this behavior and you want to be compatible with old versions of --`make', you can write a rule for the special target --`.EXPORT_ALL_VARIABLES' instead of using the `export' directive. This --will be ignored by old `make's, while the `export' directive will cause --a syntax error. -- -- Likewise, you can use `unexport' by itself to tell `make' _not_ to --export variables by default. Since this is the default behavior, you --would only need to do this if `export' had been used by itself earlier --(in an included makefile, perhaps). You *cannot* use `export' and --`unexport' by themselves to have variables exported for some commands --and not for others. The last `export' or `unexport' directive that --appears by itself determines the behavior for the entire run of `make'. -- -- As a special feature, the variable `MAKELEVEL' is changed when it is --passed down from level to level. This variable's value is a string --which is the depth of the level as a decimal number. The value is `0' --for the top-level `make'; `1' for a sub-`make', `2' for a --sub-sub-`make', and so on. The incrementation happens when `make' sets --up the environment for a command. -- -- The main use of `MAKELEVEL' is to test it in a conditional directive --(*note Conditional Parts of Makefiles: Conditionals.); this way you can --write a makefile that behaves one way if run recursively and another --way if run directly by you. -- -- You can use the variable `MAKEFILES' to cause all sub-`make' --commands to use additional makefiles. The value of `MAKEFILES' is a --whitespace-separated list of file names. This variable, if defined in --the outer-level makefile, is passed down through the environment; then --it serves as a list of extra makefiles for the sub-`make' to read --before the usual or specified ones. *Note The Variable `MAKEFILES': --MAKEFILES Variable. -- -- --File: make.info, Node: Options/Recursion, Next: -w Option, Prev: Variables/Recursion, Up: Recursion -- --5.7.3 Communicating Options to a Sub-`make' --------------------------------------------- -- --Flags such as `-s' and `-k' are passed automatically to the sub-`make' --through the variable `MAKEFLAGS'. This variable is set up --automatically by `make' to contain the flag letters that `make' --received. Thus, if you do `make -ks' then `MAKEFLAGS' gets the value --`ks'. -- -- As a consequence, every sub-`make' gets a value for `MAKEFLAGS' in --its environment. In response, it takes the flags from that value and --processes them as if they had been given as arguments. *Note Summary --of Options: Options Summary. -- -- Likewise variables defined on the command line are passed to the --sub-`make' through `MAKEFLAGS'. Words in the value of `MAKEFLAGS' that --contain `=', `make' treats as variable definitions just as if they --appeared on the command line. *Note Overriding Variables: Overriding. -- -- The options `-C', `-f', `-o', and `-W' are not put into `MAKEFLAGS'; --these options are not passed down. -- -- The `-j' option is a special case (*note Parallel Execution: --Parallel.). If you set it to some numeric value `N' and your operating --system supports it (most any UNIX system will; others typically won't), --the parent `make' and all the sub-`make's will communicate to ensure --that there are only `N' jobs running at the same time between them all. --Note that any job that is marked recursive (*note Instead of Executing --the Commands: Instead of Execution.) doesn't count against the total --jobs (otherwise we could get `N' sub-`make's running and have no slots --left over for any real work!) -- -- If your operating system doesn't support the above communication, --then `-j 1' is always put into `MAKEFLAGS' instead of the value you --specified. This is because if the `-j' option were passed down to --sub-`make's, you would get many more jobs running in parallel than you --asked for. If you give `-j' with no numeric argument, meaning to run --as many jobs as possible in parallel, this is passed down, since --multiple infinities are no more than one. -- -- If you do not want to pass the other flags down, you must change the --value of `MAKEFLAGS', like this: -- -- subsystem: -- cd subdir && $(MAKE) MAKEFLAGS= -- -- The command line variable definitions really appear in the variable --`MAKEOVERRIDES', and `MAKEFLAGS' contains a reference to this variable. --If you do want to pass flags down normally, but don't want to pass --down the command line variable definitions, you can reset --`MAKEOVERRIDES' to empty, like this: -- -- MAKEOVERRIDES = -- --This is not usually useful to do. However, some systems have a small --fixed limit on the size of the environment, and putting so much --information into the value of `MAKEFLAGS' can exceed it. If you see --the error message `Arg list too long', this may be the problem. (For --strict compliance with POSIX.2, changing `MAKEOVERRIDES' does not --affect `MAKEFLAGS' if the special target `.POSIX' appears in the --makefile. You probably do not care about this.) -- -- A similar variable `MFLAGS' exists also, for historical --compatibility. It has the same value as `MAKEFLAGS' except that it --does not contain the command line variable definitions, and it always --begins with a hyphen unless it is empty (`MAKEFLAGS' begins with a --hyphen only when it begins with an option that has no single-letter --version, such as `--warn-undefined-variables'). `MFLAGS' was --traditionally used explicitly in the recursive `make' command, like --this: -- -- subsystem: -- cd subdir && $(MAKE) $(MFLAGS) -- --but now `MAKEFLAGS' makes this usage redundant. If you want your --makefiles to be compatible with old `make' programs, use this --technique; it will work fine with more modern `make' versions too. -- -- The `MAKEFLAGS' variable can also be useful if you want to have --certain options, such as `-k' (*note Summary of Options: Options --Summary.), set each time you run `make'. You simply put a value for --`MAKEFLAGS' in your environment. You can also set `MAKEFLAGS' in a --makefile, to specify additional flags that should also be in effect for --that makefile. (Note that you cannot use `MFLAGS' this way. That --variable is set only for compatibility; `make' does not interpret a --value you set for it in any way.) -- -- When `make' interprets the value of `MAKEFLAGS' (either from the --environment or from a makefile), it first prepends a hyphen if the value --does not already begin with one. Then it chops the value into words --separated by blanks, and parses these words as if they were options --given on the command line (except that `-C', `-f', `-h', `-o', `-W', --and their long-named versions are ignored; and there is no error for an --invalid option). -- -- If you do put `MAKEFLAGS' in your environment, you should be sure not --to include any options that will drastically affect the actions of --`make' and undermine the purpose of makefiles and of `make' itself. --For instance, the `-t', `-n', and `-q' options, if put in one of these --variables, could have disastrous consequences and would certainly have --at least surprising and probably annoying effects. -- -- --File: make.info, Node: -w Option, Prev: Options/Recursion, Up: Recursion -- --5.7.4 The `--print-directory' Option -------------------------------------- -- --If you use several levels of recursive `make' invocations, the `-w' or --`--print-directory' option can make the output a lot easier to --understand by showing each directory as `make' starts processing it and --as `make' finishes processing it. For example, if `make -w' is run in --the directory `/u/gnu/make', `make' will print a line of the form: -- -- make: Entering directory `/u/gnu/make'. -- --before doing anything else, and a line of the form: -- -- make: Leaving directory `/u/gnu/make'. -- --when processing is completed. -- -- Normally, you do not need to specify this option because `make' does --it for you: `-w' is turned on automatically when you use the `-C' --option, and in sub-`make's. `make' will not automatically turn on `-w' --if you also use `-s', which says to be silent, or if you use --`--no-print-directory' to explicitly disable it. -- -- --File: make.info, Node: Sequences, Next: Empty Commands, Prev: Recursion, Up: Commands -- --5.8 Defining Canned Command Sequences --===================================== -- --When the same sequence of commands is useful in making various targets, --you can define it as a canned sequence with the `define' directive, and --refer to the canned sequence from the rules for those targets. The --canned sequence is actually a variable, so the name must not conflict --with other variable names. -- -- Here is an example of defining a canned sequence of commands: -- -- define run-yacc -- yacc $(firstword $^) -- mv y.tab.c $@ -- endef -- --Here `run-yacc' is the name of the variable being defined; `endef' --marks the end of the definition; the lines in between are the commands. --The `define' directive does not expand variable references and --function calls in the canned sequence; the `$' characters, parentheses, --variable names, and so on, all become part of the value of the variable --you are defining. *Note Defining Variables Verbatim: Defining, for a --complete explanation of `define'. -- -- The first command in this example runs Yacc on the first --prerequisite of whichever rule uses the canned sequence. The output --file from Yacc is always named `y.tab.c'. The second command moves the --output to the rule's target file name. -- -- To use the canned sequence, substitute the variable into the --commands of a rule. You can substitute it like any other variable --(*note Basics of Variable References: Reference.). Because variables --defined by `define' are recursively expanded variables, all the --variable references you wrote inside the `define' are expanded now. --For example: -- -- foo.c : foo.y -- $(run-yacc) -- --`foo.y' will be substituted for the variable `$^' when it occurs in --`run-yacc''s value, and `foo.c' for `$@'. -- -- This is a realistic example, but this particular one is not needed in --practice because `make' has an implicit rule to figure out these --commands based on the file names involved (*note Using Implicit Rules: --Implicit Rules.). -- -- In command execution, each line of a canned sequence is treated just --as if the line appeared on its own in the rule, preceded by a tab. In --particular, `make' invokes a separate subshell for each line. You can --use the special prefix characters that affect command lines (`@', `-', --and `+') on each line of a canned sequence. *Note Writing the Commands --in Rules: Commands. For example, using this canned sequence: -- -- define frobnicate -- @echo "frobnicating target $@" -- frob-step-1 $< -o $@-step-1 -- frob-step-2 $@-step-1 -o $@ -- endef -- --`make' will not echo the first line, the `echo' command. But it _will_ --echo the following two command lines. -- -- On the other hand, prefix characters on the command line that refers --to a canned sequence apply to every line in the sequence. So the rule: -- -- frob.out: frob.in -- @$(frobnicate) -- --does not echo _any_ commands. (*Note Command Echoing: Echoing, for a --full explanation of `@'.) -- -- --File: make.info, Node: Empty Commands, Prev: Sequences, Up: Commands -- --5.9 Using Empty Commands --======================== -- --It is sometimes useful to define commands which do nothing. This is --done simply by giving a command that consists of nothing but --whitespace. For example: -- -- target: ; -- --defines an empty command string for `target'. You could also use a --line beginning with a tab character to define an empty command string, --but this would be confusing because such a line looks empty. -- -- You may be wondering why you would want to define a command string --that does nothing. The only reason this is useful is to prevent a --target from getting implicit commands (from implicit rules or the --`.DEFAULT' special target; *note Implicit Rules:: and *note Defining --Last-Resort Default Rules: Last Resort.). -- -- You may be inclined to define empty command strings for targets that --are not actual files, but only exist so that their prerequisites can be --remade. However, this is not the best way to do that, because the --prerequisites may not be remade properly if the target file actually --does exist. *Note Phony Targets: Phony Targets, for a better way to do --this. -- -- --File: make.info, Node: Using Variables, Next: Conditionals, Prev: Commands, Up: Top -- --6 How to Use Variables --********************** -- --A "variable" is a name defined in a makefile to represent a string of --text, called the variable's "value". These values are substituted by --explicit request into targets, prerequisites, commands, and other parts --of the makefile. (In some other versions of `make', variables are --called "macros".) -- -- Variables and functions in all parts of a makefile are expanded when --read, except for the shell commands in rules, the right-hand sides of --variable definitions using `=', and the bodies of variable definitions --using the `define' directive. -- -- Variables can represent lists of file names, options to pass to --compilers, programs to run, directories to look in for source files, --directories to write output in, or anything else you can imagine. -- -- A variable name may be any sequence of characters not containing `:', --`#', `=', or leading or trailing whitespace. However, variable names --containing characters other than letters, numbers, and underscores --should be avoided, as they may be given special meanings in the future, --and with some shells they cannot be passed through the environment to a --sub-`make' (*note Communicating Variables to a Sub-`make': --Variables/Recursion.). -- -- Variable names are case-sensitive. The names `foo', `FOO', and --`Foo' all refer to different variables. -- -- It is traditional to use upper case letters in variable names, but we --recommend using lower case letters for variable names that serve --internal purposes in the makefile, and reserving upper case for --parameters that control implicit rules or for parameters that the user --should override with command options (*note Overriding Variables: --Overriding.). -- -- A few variables have names that are a single punctuation character or --just a few characters. These are the "automatic variables", and they --have particular specialized uses. *Note Automatic Variables::. -- --* Menu: -- --* 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. --* Target-specific:: Variable values can be defined on a per-target -- basis. --* Pattern-specific:: Target-specific variable values can be applied -- to a group of targets that match a pattern. -- -- --File: make.info, Node: Reference, Next: Flavors, Prev: Using Variables, Up: Using Variables -- --6.1 Basics of Variable References --================================= -- --To substitute a variable's value, write a dollar sign followed by the --name of the variable in parentheses or braces: either `$(foo)' or --`${foo}' is a valid reference to the variable `foo'. This special --significance of `$' is why you must write `$$' to have the effect of a --single dollar sign in a file name or command. -- -- Variable references can be used in any context: targets, --prerequisites, commands, most directives, and new variable values. --Here is an example of a common case, where a variable holds the names --of all the object files in a program: -- -- objects = program.o foo.o utils.o -- program : $(objects) -- cc -o program $(objects) -- -- $(objects) : defs.h -- -- Variable references work by strict textual substitution. Thus, the --rule -- -- foo = c -- prog.o : prog.$(foo) -- $(foo)$(foo) -$(foo) prog.$(foo) -- --could be used to compile a C program `prog.c'. Since spaces before the --variable value are ignored in variable assignments, the value of `foo' --is precisely `c'. (Don't actually write your makefiles this way!) -- -- A dollar sign followed by a character other than a dollar sign, --open-parenthesis or open-brace treats that single character as the --variable name. Thus, you could reference the variable `x' with `$x'. --However, this practice is strongly discouraged, except in the case of --the automatic variables (*note Automatic Variables::). -- -- --File: make.info, Node: Flavors, Next: Advanced, Prev: Reference, Up: Using Variables -- --6.2 The Two Flavors of Variables --================================ -- --There are two ways that a variable in GNU `make' can have a value; we --call them the two "flavors" of variables. The two flavors are --distinguished in how they are defined and in what they do when expanded. -- -- The first flavor of variable is a "recursively expanded" variable. --Variables of this sort are defined by lines using `=' (*note Setting --Variables: Setting.) or by the `define' directive (*note Defining --Variables Verbatim: Defining.). The value you specify is installed --verbatim; if it contains references to other variables, these --references are expanded whenever this variable is substituted (in the --course of expanding some other string). When this happens, it is --called "recursive expansion". -- -- For example, -- -- foo = $(bar) -- bar = $(ugh) -- ugh = Huh? -- -- all:;echo $(foo) -- --will echo `Huh?': `$(foo)' expands to `$(bar)' which expands to --`$(ugh)' which finally expands to `Huh?'. -- -- This flavor of variable is the only sort supported by other versions --of `make'. It has its advantages and its disadvantages. An advantage --(most would say) is that: -- -- CFLAGS = $(include_dirs) -O -- include_dirs = -Ifoo -Ibar -- --will do what was intended: when `CFLAGS' is expanded in a command, it --will expand to `-Ifoo -Ibar -O'. A major disadvantage is that you --cannot append something on the end of a variable, as in -- -- CFLAGS = $(CFLAGS) -O -- --because it will cause an infinite loop in the variable expansion. --(Actually `make' detects the infinite loop and reports an error.) -- -- Another disadvantage is that any functions (*note Functions for --Transforming Text: Functions.) referenced in the definition will be --executed every time the variable is expanded. This makes `make' run --slower; worse, it causes the `wildcard' and `shell' functions to give --unpredictable results because you cannot easily control when they are --called, or even how many times. -- -- To avoid all the problems and inconveniences of recursively expanded --variables, there is another flavor: simply expanded variables. -- -- "Simply expanded variables" are defined by lines using `:=' (*note --Setting Variables: Setting.). The value of a simply expanded variable --is scanned once and for all, expanding any references to other --variables and functions, when the variable is defined. The actual --value of the simply expanded variable is the result of expanding the --text that you write. It does not contain any references to other --variables; it contains their values _as of the time this variable was --defined_. Therefore, -- -- x := foo -- y := $(x) bar -- x := later -- --is equivalent to -- -- y := foo bar -- x := later -- -- When a simply expanded variable is referenced, its value is --substituted verbatim. -- -- Here is a somewhat more complicated example, illustrating the use of --`:=' in conjunction with the `shell' function. (*Note The `shell' --Function: Shell Function.) This example also shows use of the variable --`MAKELEVEL', which is changed when it is passed down from level to --level. (*Note Communicating Variables to a Sub-`make': --Variables/Recursion, for information about `MAKELEVEL'.) -- -- ifeq (0,${MAKELEVEL}) -- whoami := $(shell whoami) -- host-type := $(shell arch) -- MAKE := ${MAKE} host-type=${host-type} whoami=${whoami} -- endif -- --An advantage of this use of `:=' is that a typical `descend into a --directory' command then looks like this: -- -- ${subdirs}: -- ${MAKE} -C $@ all -- -- Simply expanded variables generally make complicated makefile --programming more predictable because they work like variables in most --programming languages. They allow you to redefine a variable using its --own value (or its value processed in some way by one of the expansion --functions) and to use the expansion functions much more efficiently --(*note Functions for Transforming Text: Functions.). -- -- You can also use them to introduce controlled leading whitespace into --variable values. Leading whitespace characters are discarded from your --input before substitution of variable references and function calls; --this means you can include leading spaces in a variable value by --protecting them with variable references, like this: -- -- nullstring := -- space := $(nullstring) # end of the line -- --Here the value of the variable `space' is precisely one space. The --comment `# end of the line' is included here just for clarity. Since --trailing space characters are _not_ stripped from variable values, just --a space at the end of the line would have the same effect (but be --rather hard to read). If you put whitespace at the end of a variable --value, it is a good idea to put a comment like that at the end of the --line to make your intent clear. Conversely, if you do _not_ want any --whitespace characters at the end of your variable value, you must --remember not to put a random comment on the end of the line after some --whitespace, such as this: -- -- dir := /foo/bar # directory to put the frobs in -- --Here the value of the variable `dir' is `/foo/bar ' (with four --trailing spaces), which was probably not the intention. (Imagine --something like `$(dir)/file' with this definition!) -- -- There is another assignment operator for variables, `?='. This is --called a conditional variable assignment operator, because it only has --an effect if the variable is not yet defined. This statement: -- -- FOO ?= bar -- --is exactly equivalent to this (*note The `origin' Function: Origin --Function.): -- -- ifeq ($(origin FOO), undefined) -- FOO = bar -- endif -- -- Note that a variable set to an empty value is still defined, so `?=' --will not set that variable. -- -- --File: make.info, Node: Advanced, Next: Values, Prev: Flavors, Up: Using Variables -- --6.3 Advanced Features for Reference to Variables --================================================ -- --This section describes some advanced features you can use to reference --variables in more flexible ways. -- --* Menu: -- --* Substitution Refs:: Referencing a variable with -- substitutions on the value. --* Computed Names:: Computing the name of the variable to refer to. -- -- --File: make.info, Node: Substitution Refs, Next: Computed Names, Prev: Advanced, Up: Advanced -- --6.3.1 Substitution References ------------------------------- -- --A "substitution reference" substitutes the value of a variable with --alterations that you specify. It has the form `$(VAR:A=B)' (or --`${VAR:A=B}') and its meaning is to take the value of the variable VAR, --replace every A at the end of a word with B in that value, and --substitute the resulting string. -- -- When we say "at the end of a word", we mean that A must appear --either followed by whitespace or at the end of the value in order to be --replaced; other occurrences of A in the value are unaltered. For --example: -- -- foo := a.o b.o c.o -- bar := $(foo:.o=.c) -- --sets `bar' to `a.c b.c c.c'. *Note Setting Variables: Setting. -- -- A substitution reference is actually an abbreviation for use of the --`patsubst' expansion function (*note Functions for String Substitution --and Analysis: Text Functions.). We provide substitution references as --well as `patsubst' for compatibility with other implementations of --`make'. -- -- Another type of substitution reference lets you use the full power of --the `patsubst' function. It has the same form `$(VAR:A=B)' described --above, except that now A must contain a single `%' character. This --case is equivalent to `$(patsubst A,B,$(VAR))'. *Note Functions for --String Substitution and Analysis: Text Functions, for a description of --the `patsubst' function. -- --For example: -- -- foo := a.o b.o c.o -- bar := $(foo:%.o=%.c) -- --sets `bar' to `a.c b.c c.c'. -- -- --File: make.info, Node: Computed Names, Prev: Substitution Refs, Up: Advanced -- --6.3.2 Computed Variable Names ------------------------------- -- --Computed variable names are a complicated concept needed only for --sophisticated makefile programming. For most purposes you need not --consider them, except to know that making a variable with a dollar sign --in its name might have strange results. However, if you are the type --that wants to understand everything, or you are actually interested in --what they do, read on. -- -- Variables may be referenced inside the name of a variable. This is --called a "computed variable name" or a "nested variable reference". --For example, -- -- x = y -- y = z -- a := $($(x)) -- --defines `a' as `z': the `$(x)' inside `$($(x))' expands to `y', so --`$($(x))' expands to `$(y)' which in turn expands to `z'. Here the --name of the variable to reference is not stated explicitly; it is --computed by expansion of `$(x)'. The reference `$(x)' here is nested --within the outer variable reference. -- -- The previous example shows two levels of nesting, but any number of --levels is possible. For example, here are three levels: -- -- x = y -- y = z -- z = u -- a := $($($(x))) -- --Here the innermost `$(x)' expands to `y', so `$($(x))' expands to --`$(y)' which in turn expands to `z'; now we have `$(z)', which becomes --`u'. -- -- References to recursively-expanded variables within a variable name --are reexpanded in the usual fashion. For example: -- -- x = $(y) -- y = z -- z = Hello -- a := $($(x)) -- --defines `a' as `Hello': `$($(x))' becomes `$($(y))' which becomes --`$(z)' which becomes `Hello'. -- -- Nested variable references can also contain modified references and --function invocations (*note Functions for Transforming Text: --Functions.), just like any other reference. For example, using the --`subst' function (*note Functions for String Substitution and Analysis: --Text Functions.): -- -- x = variable1 -- variable2 := Hello -- y = $(subst 1,2,$(x)) -- z = y -- a := $($($(z))) -- --eventually defines `a' as `Hello'. It is doubtful that anyone would --ever want to write a nested reference as convoluted as this one, but it --works: `$($($(z)))' expands to `$($(y))' which becomes `$($(subst --1,2,$(x)))'. This gets the value `variable1' from `x' and changes it --by substitution to `variable2', so that the entire string becomes --`$(variable2)', a simple variable reference whose value is `Hello'. -- -- A computed variable name need not consist entirely of a single --variable reference. It can contain several variable references, as --well as some invariant text. For example, -- -- a_dirs := dira dirb -- 1_dirs := dir1 dir2 -- -- a_files := filea fileb -- 1_files := file1 file2 -- -- ifeq "$(use_a)" "yes" -- a1 := a -- else -- a1 := 1 -- endif -- -- ifeq "$(use_dirs)" "yes" -- df := dirs -- else -- df := files -- endif -- -- dirs := $($(a1)_$(df)) -- --will give `dirs' the same value as `a_dirs', `1_dirs', `a_files' or --`1_files' depending on the settings of `use_a' and `use_dirs'. -- -- Computed variable names can also be used in substitution references: -- -- a_objects := a.o b.o c.o -- 1_objects := 1.o 2.o 3.o -- -- sources := $($(a1)_objects:.o=.c) -- --defines `sources' as either `a.c b.c c.c' or `1.c 2.c 3.c', depending --on the value of `a1'. -- -- The only restriction on this sort of use of nested variable --references is that they cannot specify part of the name of a function --to be called. This is because the test for a recognized function name --is done before the expansion of nested references. For example, -- -- ifdef do_sort -- func := sort -- else -- func := strip -- endif -- -- bar := a d b g q c -- -- foo := $($(func) $(bar)) -- --attempts to give `foo' the value of the variable `sort a d b g q c' or --`strip a d b g q c', rather than giving `a d b g q c' as the argument --to either the `sort' or the `strip' function. This restriction could --be removed in the future if that change is shown to be a good idea. -- -- You can also use computed variable names in the left-hand side of a --variable assignment, or in a `define' directive, as in: -- -- dir = foo -- $(dir)_sources := $(wildcard $(dir)/*.c) -- define $(dir)_print -- lpr $($(dir)_sources) -- endef -- --This example defines the variables `dir', `foo_sources', and --`foo_print'. -- -- Note that "nested variable references" are quite different from --"recursively expanded variables" (*note The Two Flavors of Variables: --Flavors.), though both are used together in complex ways when doing --makefile programming. -- -- --File: make.info, Node: Values, Next: Setting, Prev: Advanced, Up: Using Variables -- --6.4 How Variables Get Their Values --================================== -- --Variables can get values in several different ways: -- -- * You can specify an overriding value when you run `make'. *Note -- Overriding Variables: Overriding. -- -- * You can specify a value in the makefile, either with an assignment -- (*note Setting Variables: Setting.) or with a verbatim definition -- (*note Defining Variables Verbatim: Defining.). -- -- * Variables in the environment become `make' variables. *Note -- Variables from the Environment: Environment. -- -- * Several "automatic" variables are given new values for each rule. -- Each of these has a single conventional use. *Note Automatic -- Variables::. -- -- * Several variables have constant initial values. *Note Variables -- Used by Implicit Rules: Implicit Variables. -- -- --File: make.info, Node: Setting, Next: Appending, Prev: Values, Up: Using Variables -- --6.5 Setting Variables --===================== -- --To set a variable from the makefile, write a line starting with the --variable name followed by `=' or `:='. Whatever follows the `=' or --`:=' on the line becomes the value. For example, -- -- objects = main.o foo.o bar.o utils.o -- --defines a variable named `objects'. Whitespace around the variable --name and immediately after the `=' is ignored. -- -- Variables defined with `=' are "recursively expanded" variables. --Variables defined with `:=' are "simply expanded" variables; these --definitions can contain variable references which will be expanded --before the definition is made. *Note The Two Flavors of Variables: --Flavors. -- -- The variable name may contain function and variable references, which --are expanded when the line is read to find the actual variable name to --use. -- -- There is no limit on the length of the value of a variable except the --amount of swapping space on the computer. When a variable definition is --long, it is a good idea to break it into several lines by inserting --backslash-newline at convenient places in the definition. This will not --affect the functioning of `make', but it will make the makefile easier --to read. -- -- Most variable names are considered to have the empty string as a --value if you have never set them. Several variables have built-in --initial values that are not empty, but you can set them in the usual --ways (*note Variables Used by Implicit Rules: Implicit Variables.). --Several special variables are set automatically to a new value for each --rule; these are called the "automatic" variables (*note Automatic --Variables::). -- -- If you'd like a variable to be set to a value only if it's not --already set, then you can use the shorthand operator `?=' instead of --`='. These two settings of the variable `FOO' are identical (*note The --`origin' Function: Origin Function.): -- -- FOO ?= bar -- --and -- -- ifeq ($(origin FOO), undefined) -- FOO = bar -- endif -- -- --File: make.info, Node: Appending, Next: Override Directive, Prev: Setting, Up: Using Variables -- --6.6 Appending More Text to Variables --==================================== -- --Often it is useful to add more text to the value of a variable already --defined. You do this with a line containing `+=', like this: -- -- objects += another.o -- --This takes the value of the variable `objects', and adds the text --`another.o' to it (preceded by a single space). Thus: -- -- objects = main.o foo.o bar.o utils.o -- objects += another.o -- --sets `objects' to `main.o foo.o bar.o utils.o another.o'. -- -- Using `+=' is similar to: -- -- objects = main.o foo.o bar.o utils.o -- objects := $(objects) another.o -- --but differs in ways that become important when you use more complex --values. -- -- When the variable in question has not been defined before, `+=' acts --just like normal `=': it defines a recursively-expanded variable. --However, when there _is_ a previous definition, exactly what `+=' does --depends on what flavor of variable you defined originally. *Note The --Two Flavors of Variables: Flavors, for an explanation of the two --flavors of variables. -- -- When you add to a variable's value with `+=', `make' acts --essentially as if you had included the extra text in the initial --definition of the variable. If you defined it first with `:=', making --it a simply-expanded variable, `+=' adds to that simply-expanded --definition, and expands the new text before appending it to the old --value just as `:=' does (see *Note Setting Variables: Setting, for a --full explanation of `:='). In fact, -- -- variable := value -- variable += more -- --is exactly equivalent to: -- -- -- variable := value -- variable := $(variable) more -- -- On the other hand, when you use `+=' with a variable that you defined --first to be recursively-expanded using plain `=', `make' does something --a bit different. Recall that when you define a recursively-expanded --variable, `make' does not expand the value you set for variable and --function references immediately. Instead it stores the text verbatim, --and saves these variable and function references to be expanded later, --when you refer to the new variable (*note The Two Flavors of Variables: --Flavors.). When you use `+=' on a recursively-expanded variable, it is --this unexpanded text to which `make' appends the new text you specify. -- -- variable = value -- variable += more -- --is roughly equivalent to: -- -- temp = value -- variable = $(temp) more -- --except that of course it never defines a variable called `temp'. The --importance of this comes when the variable's old value contains --variable references. Take this common example: -- -- CFLAGS = $(includes) -O -- ... -- CFLAGS += -pg # enable profiling -- --The first line defines the `CFLAGS' variable with a reference to another --variable, `includes'. (`CFLAGS' is used by the rules for C --compilation; *note Catalogue of Implicit Rules: Catalogue of Rules.) --Using `=' for the definition makes `CFLAGS' a recursively-expanded --variable, meaning `$(includes) -O' is _not_ expanded when `make' --processes the definition of `CFLAGS'. Thus, `includes' need not be --defined yet for its value to take effect. It only has to be defined --before any reference to `CFLAGS'. If we tried to append to the value --of `CFLAGS' without using `+=', we might do it like this: -- -- CFLAGS := $(CFLAGS) -pg # enable profiling -- --This is pretty close, but not quite what we want. Using `:=' redefines --`CFLAGS' as a simply-expanded variable; this means `make' expands the --text `$(CFLAGS) -pg' before setting the variable. If `includes' is not --yet defined, we get ` -O -pg', and a later definition of `includes' --will have no effect. Conversely, by using `+=' we set `CFLAGS' to the --_unexpanded_ value `$(includes) -O -pg'. Thus we preserve the --reference to `includes', so if that variable gets defined at any later --point, a reference like `$(CFLAGS)' still uses its value. -- -- --File: make.info, Node: Override Directive, Next: Defining, Prev: Appending, Up: Using Variables -- --6.7 The `override' Directive --============================ -- --If a variable has been set with a command argument (*note Overriding --Variables: Overriding.), then ordinary assignments in the makefile are --ignored. If you want to set the variable in the makefile even though --it was set with a command argument, you can use an `override' --directive, which is a line that looks like this: -- -- override VARIABLE = VALUE -- --or -- -- override VARIABLE := VALUE -- -- To append more text to a variable defined on the command line, use: -- -- override VARIABLE += MORE TEXT -- --*Note Appending More Text to Variables: Appending. -- -- The `override' directive was not invented for escalation in the war --between makefiles and command arguments. It was invented so you can --alter and add to values that the user specifies with command arguments. -- -- For example, suppose you always want the `-g' switch when you run the --C compiler, but you would like to allow the user to specify the other --switches with a command argument just as usual. You could use this --`override' directive: -- -- override CFLAGS += -g -- -- You can also use `override' directives with `define' directives. --This is done as you might expect: -- -- override define foo -- bar -- endef -- --*Note Defining Variables Verbatim: Defining. -- -- --File: make.info, Node: Defining, Next: Environment, Prev: Override Directive, Up: Using Variables -- --6.8 Defining Variables Verbatim --=============================== -- --Another way to set the value of a variable is to use the `define' --directive. This directive has an unusual syntax which allows newline --characters to be included in the value, which is convenient for defining --both canned sequences of commands (*note Defining Canned Command --Sequences: Sequences.), and also sections of makefile syntax to use --with `eval' (*note Eval Function::). -- -- The `define' directive is followed on the same line by the name of --the variable and nothing more. The value to give the variable appears --on the following lines. The end of the value is marked by a line --containing just the word `endef'. Aside from this difference in --syntax, `define' works just like `=': it creates a recursively-expanded --variable (*note The Two Flavors of Variables: Flavors.). The variable --name may contain function and variable references, which are expanded --when the directive is read to find the actual variable name to use. -- -- You may nest `define' directives: `make' will keep track of nested --directives and report an error if they are not all properly closed with --`endef'. Note that lines beginning with tab characters are considered --part of a command script, so any `define' or `endef' strings appearing --on such a line will not be considered `make' operators. -- -- define two-lines -- echo foo -- echo $(bar) -- endef -- -- The value in an ordinary assignment cannot contain a newline; but the --newlines that separate the lines of the value in a `define' become part --of the variable's value (except for the final newline which precedes --the `endef' and is not considered part of the value). -- -- When used in a command script, the previous example is functionally --equivalent to this: -- -- two-lines = echo foo; echo $(bar) -- --since two commands separated by semicolon behave much like two separate --shell commands. However, note that using two separate lines means --`make' will invoke the shell twice, running an independent subshell for --each line. *Note Command Execution: Execution. -- -- If you want variable definitions made with `define' to take --precedence over command-line variable definitions, you can use the --`override' directive together with `define': -- -- override define two-lines -- foo -- $(bar) -- endef -- --*Note The `override' Directive: Override Directive. -- -- --File: make.info, Node: Environment, Next: Target-specific, Prev: Defining, Up: Using Variables -- --6.9 Variables from the Environment --================================== -- --Variables in `make' can come from the environment in which `make' is --run. Every environment variable that `make' sees when it starts up is --transformed into a `make' variable with the same name and value. --However, an explicit assignment in the makefile, or with a command --argument, overrides the environment. (If the `-e' flag is specified, --then values from the environment override assignments in the makefile. --*Note Summary of Options: Options Summary. But this is not recommended --practice.) -- -- Thus, by setting the variable `CFLAGS' in your environment, you can --cause all C compilations in most makefiles to use the compiler switches --you prefer. This is safe for variables with standard or conventional --meanings because you know that no makefile will use them for other --things. (Note this is not totally reliable; some makefiles set --`CFLAGS' explicitly and therefore are not affected by the value in the --environment.) -- -- When `make' runs a command script, variables defined in the makefile --are placed into the environment of that command. This allows you to --pass values to sub-`make' invocations (*note Recursive Use of `make': --Recursion.). By default, only variables that came from the environment --or the command line are passed to recursive invocations. You can use --the `export' directive to pass other variables. *Note Communicating --Variables to a Sub-`make': Variables/Recursion, for full details. -- -- Other use of variables from the environment is not recommended. It --is not wise for makefiles to depend for their functioning on --environment variables set up outside their control, since this would --cause different users to get different results from the same makefile. --This is against the whole purpose of most makefiles. -- -- Such problems would be especially likely with the variable `SHELL', --which is normally present in the environment to specify the user's --choice of interactive shell. It would be very undesirable for this --choice to affect `make'; so, `make' handles the `SHELL' environment --variable in a special way; see *Note Choosing the Shell::. -- -- --File: make.info, Node: Target-specific, Next: Pattern-specific, Prev: Environment, Up: Using Variables -- --6.10 Target-specific Variable Values --==================================== -- --Variable values in `make' are usually global; that is, they are the --same regardless of where they are evaluated (unless they're reset, of --course). One exception to that is automatic variables (*note Automatic --Variables::). -- -- The other exception is "target-specific variable values". This --feature allows you to define different values for the same variable, --based on the target that `make' is currently building. As with --automatic variables, these values are only available within the context --of a target's command script (and in other target-specific assignments). -- -- Set a target-specific variable value like this: -- -- TARGET ... : VARIABLE-ASSIGNMENT -- --or like this: -- -- TARGET ... : override VARIABLE-ASSIGNMENT -- --or like this: -- -- TARGET ... : export VARIABLE-ASSIGNMENT -- -- Multiple TARGET values create a target-specific variable value for --each member of the target list individually. -- -- The VARIABLE-ASSIGNMENT can be any valid form of assignment; --recursive (`='), static (`:='), appending (`+='), or conditional --(`?='). All variables that appear within the VARIABLE-ASSIGNMENT are --evaluated within the context of the target: thus, any --previously-defined target-specific variable values will be in effect. --Note that this variable is actually distinct from any "global" value: --the two variables do not have to have the same flavor (recursive vs. --static). -- -- Target-specific variables have the same priority as any other --makefile variable. Variables provided on the command-line (and in the --environment if the `-e' option is in force) will take precedence. --Specifying the `override' directive will allow the target-specific --variable value to be preferred. -- -- There is one more special feature of target-specific variables: when --you define a target-specific variable that variable value is also in --effect for all prerequisites of this target, and all their --prerequisites, etc. (unless those prerequisites override that variable --with their own target-specific variable value). So, for example, a --statement like this: -- -- prog : CFLAGS = -g -- prog : prog.o foo.o bar.o -- --will set `CFLAGS' to `-g' in the command script for `prog', but it will --also set `CFLAGS' to `-g' in the command scripts that create `prog.o', --`foo.o', and `bar.o', and any command scripts which create their --prerequisites. -- -- Be aware that a given prerequisite will only be built once per --invocation of make, at most. If the same file is a prerequisite of --multiple targets, and each of those targets has a different value for --the same target-specific variable, then the first target to be built --will cause that prerequisite to be built and the prerequisite will --inherit the target-specific value from the first target. It will --ignore the target-specific values from any other targets. -- -- --File: make.info, Node: Pattern-specific, Prev: Target-specific, Up: Using Variables -- --6.11 Pattern-specific Variable Values --===================================== -- --In addition to target-specific variable values (*note Target-specific --Variable Values: Target-specific.), GNU `make' supports --pattern-specific variable values. In this form, the variable is --defined for any target that matches the pattern specified. If a target --matches more than one pattern, all the matching pattern-specific --variables are interpreted in the order in which they were defined in --the makefile, and collected together into one set. Variables defined --in this way are searched after any target-specific variables defined --explicitly for that target, and before target-specific variables --defined for the parent target. -- -- Set a pattern-specific variable value like this: -- -- PATTERN ... : VARIABLE-ASSIGNMENT -- --or like this: -- -- PATTERN ... : override VARIABLE-ASSIGNMENT -- --where PATTERN is a %-pattern. As with target-specific variable values, --multiple PATTERN values create a pattern-specific variable value for --each pattern individually. The VARIABLE-ASSIGNMENT can be any valid --form of assignment. Any command-line variable setting will take --precedence, unless `override' is specified. -- -- For example: -- -- %.o : CFLAGS = -O -- --will assign `CFLAGS' the value of `-O' for all targets matching the --pattern `%.o'. -- -- --File: make.info, Node: Conditionals, Next: Functions, Prev: Using Variables, Up: Top -- --7 Conditional Parts of Makefiles --******************************** -- --A "conditional" causes part of a makefile to be obeyed or ignored --depending on the values of variables. Conditionals can compare the --value of one variable to another, or the value of a variable to a --constant string. Conditionals control what `make' actually "sees" in --the makefile, so they _cannot_ be used to control shell commands at the --time of execution. -- --* Menu: -- --* Conditional Example:: Example of a conditional --* Conditional Syntax:: The syntax of conditionals. --* Testing Flags:: Conditionals that test flags. -- -- --File: make.info, Node: Conditional Example, Next: Conditional Syntax, Prev: Conditionals, Up: Conditionals -- --7.1 Example of a Conditional --============================ -- --The following example of a conditional tells `make' to use one set of --libraries if the `CC' variable is `gcc', and a different set of --libraries otherwise. It works by controlling which of two command --lines will be used as the command for a rule. The result is that --`CC=gcc' as an argument to `make' changes not only which compiler is --used but also which libraries are linked. -- -- libs_for_gcc = -lgnu -- normal_libs = -- -- foo: $(objects) -- ifeq ($(CC),gcc) -- $(CC) -o foo $(objects) $(libs_for_gcc) -- else -- $(CC) -o foo $(objects) $(normal_libs) -- endif -- -- This conditional uses three directives: one `ifeq', one `else' and --one `endif'. -- -- The `ifeq' directive begins the conditional, and specifies the --condition. It contains two arguments, separated by a comma and --surrounded by parentheses. Variable substitution is performed on both --arguments and then they are compared. The lines of the makefile --following the `ifeq' are obeyed if the two arguments match; otherwise --they are ignored. -- -- The `else' directive causes the following lines to be obeyed if the --previous conditional failed. In the example above, this means that the --second alternative linking command is used whenever the first --alternative is not used. It is optional to have an `else' in a --conditional. -- -- The `endif' directive ends the conditional. Every conditional must --end with an `endif'. Unconditional makefile text follows. -- -- As this example illustrates, conditionals work at the textual level: --the lines of the conditional are treated as part of the makefile, or --ignored, according to the condition. This is why the larger syntactic --units of the makefile, such as rules, may cross the beginning or the --end of the conditional. -- -- When the variable `CC' has the value `gcc', the above example has --this effect: -- -- foo: $(objects) -- $(CC) -o foo $(objects) $(libs_for_gcc) -- --When the variable `CC' has any other value, the effect is this: -- -- foo: $(objects) -- $(CC) -o foo $(objects) $(normal_libs) -- -- Equivalent results can be obtained in another way by --conditionalizing a variable assignment and then using the variable --unconditionally: -- -- libs_for_gcc = -lgnu -- normal_libs = -- -- ifeq ($(CC),gcc) -- libs=$(libs_for_gcc) -- else -- libs=$(normal_libs) -- endif -- -- foo: $(objects) -- $(CC) -o foo $(objects) $(libs) -- -- --File: make.info, Node: Conditional Syntax, Next: Testing Flags, Prev: Conditional Example, Up: Conditionals -- --7.2 Syntax of Conditionals --========================== -- --The syntax of a simple conditional with no `else' is as follows: -- -- CONDITIONAL-DIRECTIVE -- TEXT-IF-TRUE -- endif -- --The TEXT-IF-TRUE may be any lines of text, to be considered as part of --the makefile if the condition is true. If the condition is false, no --text is used instead. -- -- The syntax of a complex conditional is as follows: -- -- CONDITIONAL-DIRECTIVE -- TEXT-IF-TRUE -- else -- TEXT-IF-FALSE -- endif -- -- or: -- -- CONDITIONAL-DIRECTIVE -- TEXT-IF-ONE-IS-TRUE -- else CONDITIONAL-DIRECTIVE -- TEXT-IF-TRUE -- else -- TEXT-IF-FALSE -- endif -- --There can be as many "`else' CONDITIONAL-DIRECTIVE" clauses as --necessary. Once a given condition is true, TEXT-IF-TRUE is used and no --other clause is used; if no condition is true then TEXT-IF-FALSE is --used. The TEXT-IF-TRUE and TEXT-IF-FALSE can be any number of lines of --text. -- -- The syntax of the CONDITIONAL-DIRECTIVE is the same whether the --conditional is simple or complex; after an `else' or not. There are --four different directives that test different conditions. Here is a --table of them: -- --`ifeq (ARG1, ARG2)' --`ifeq 'ARG1' 'ARG2'' --`ifeq "ARG1" "ARG2"' --`ifeq "ARG1" 'ARG2'' --`ifeq 'ARG1' "ARG2"' -- Expand all variable references in ARG1 and ARG2 and compare them. -- If they are identical, the TEXT-IF-TRUE is effective; otherwise, -- the TEXT-IF-FALSE, if any, is effective. -- -- Often you want to test if a variable has a non-empty value. When -- the value results from complex expansions of variables and -- functions, expansions you would consider empty may actually -- contain whitespace characters and thus are not seen as empty. -- However, you can use the `strip' function (*note Text Functions::) -- to avoid interpreting whitespace as a non-empty value. For -- example: -- -- ifeq ($(strip $(foo)),) -- TEXT-IF-EMPTY -- endif -- -- will evaluate TEXT-IF-EMPTY even if the expansion of `$(foo)' -- contains whitespace characters. -- --`ifneq (ARG1, ARG2)' --`ifneq 'ARG1' 'ARG2'' --`ifneq "ARG1" "ARG2"' --`ifneq "ARG1" 'ARG2'' --`ifneq 'ARG1' "ARG2"' -- Expand all variable references in ARG1 and ARG2 and compare them. -- If they are different, the TEXT-IF-TRUE is effective; otherwise, -- the TEXT-IF-FALSE, if any, is effective. -- --`ifdef VARIABLE-NAME' -- The `ifdef' form takes the _name_ of a variable as its argument, -- not a reference to a variable. The value of that variable has a -- non-empty value, the TEXT-IF-TRUE is effective; otherwise, the -- TEXT-IF-FALSE, if any, is effective. Variables that have never -- been defined have an empty value. The text VARIABLE-NAME is -- expanded, so it could be a variable or function that expands to -- the name of a variable. For example: -- -- bar = true -- foo = bar -- ifdef $(foo) -- frobozz = yes -- endif -- -- The variable reference `$(foo)' is expanded, yielding `bar', which -- is considered to be the name of a variable. The variable `bar' is -- not expanded, but its value is examined to determine if it is -- non-empty. -- -- Note that `ifdef' only tests whether a variable has a value. It -- does not expand the variable to see if that value is nonempty. -- Consequently, tests using `ifdef' return true for all definitions -- except those like `foo ='. To test for an empty value, use -- `ifeq ($(foo),)'. For example, -- -- bar = -- foo = $(bar) -- ifdef foo -- frobozz = yes -- else -- frobozz = no -- endif -- -- sets `frobozz' to `yes', while: -- -- foo = -- ifdef foo -- frobozz = yes -- else -- frobozz = no -- endif -- -- sets `frobozz' to `no'. -- --`ifndef VARIABLE-NAME' -- If the variable VARIABLE-NAME has an empty value, the TEXT-IF-TRUE -- is effective; otherwise, the TEXT-IF-FALSE, if any, is effective. -- The rules for expansion and testing of VARIABLE-NAME are identical -- to the `ifdef' directive. -- -- Extra spaces are allowed and ignored at the beginning of the --conditional directive line, but a tab is not allowed. (If the line --begins with a tab, it will be considered a command for a rule.) Aside --from this, extra spaces or tabs may be inserted with no effect anywhere --except within the directive name or within an argument. A comment --starting with `#' may appear at the end of the line. -- -- The other two directives that play a part in a conditional are `else' --and `endif'. Each of these directives is written as one word, with no --arguments. Extra spaces are allowed and ignored at the beginning of the --line, and spaces or tabs at the end. A comment starting with `#' may --appear at the end of the line. -- -- Conditionals affect which lines of the makefile `make' uses. If the --condition is true, `make' reads the lines of the TEXT-IF-TRUE as part --of the makefile; if the condition is false, `make' ignores those lines --completely. It follows that syntactic units of the makefile, such as --rules, may safely be split across the beginning or the end of the --conditional. -- -- `make' evaluates conditionals when it reads a makefile. --Consequently, you cannot use automatic variables in the tests of --conditionals because they are not defined until commands are run (*note --Automatic Variables::). -- -- To prevent intolerable confusion, it is not permitted to start a --conditional in one makefile and end it in another. However, you may --write an `include' directive within a conditional, provided you do not --attempt to terminate the conditional inside the included file. -- -- --File: make.info, Node: Testing Flags, Prev: Conditional Syntax, Up: Conditionals -- --7.3 Conditionals that Test Flags --================================ -- --You can write a conditional that tests `make' command flags such as --`-t' by using the variable `MAKEFLAGS' together with the `findstring' --function (*note Functions for String Substitution and Analysis: Text --Functions.). This is useful when `touch' is not enough to make a file --appear up to date. -- -- The `findstring' function determines whether one string appears as a --substring of another. If you want to test for the `-t' flag, use `t' --as the first string and the value of `MAKEFLAGS' as the other. -- -- For example, here is how to arrange to use `ranlib -t' to finish --marking an archive file up to date: -- -- archive.a: ... -- ifneq (,$(findstring t,$(MAKEFLAGS))) -- +touch archive.a -- +ranlib -t archive.a -- else -- ranlib archive.a -- endif -- --The `+' prefix marks those command lines as "recursive" so that they --will be executed despite use of the `-t' flag. *Note Recursive Use of --`make': Recursion. -- -- --File: make.info, Node: Functions, Next: Running, Prev: Conditionals, Up: Top -- --8 Functions for Transforming Text --********************************* -- --"Functions" allow you to do text processing in the makefile to compute --the files to operate on or the commands to use. You use a function in a --"function call", where you give the name of the function and some text --(the "arguments") for the function to operate on. The result of the --function's processing is substituted into the makefile at the point of --the call, just as a variable might be substituted. -- --* Menu: -- --* Syntax of Functions:: How to write a function call. --* Text Functions:: General-purpose text manipulation functions. --* File Name Functions:: Functions for manipulating file names. --* Conditional Functions:: Functions that implement conditions. --* Foreach Function:: Repeat some text with controlled variation. --* Call Function:: Expand a user-defined function. --* Value Function:: Return the un-expanded value of a variable. --* Eval Function:: Evaluate the arguments as makefile syntax. --* Origin Function:: Find where a variable got its value. --* Flavor Function:: Find out the flavor of a variable. --* Shell Function:: Substitute the output of a shell command. --* Make Control Functions:: Functions that control how make runs. -- -- --File: make.info, Node: Syntax of Functions, Next: Text Functions, Prev: Functions, Up: Functions -- --8.1 Function Call Syntax --======================== -- --A function call resembles a variable reference. It looks like this: -- -- $(FUNCTION ARGUMENTS) -- --or like this: -- -- ${FUNCTION ARGUMENTS} -- -- Here FUNCTION is a function name; one of a short list of names that --are part of `make'. You can also essentially create your own functions --by using the `call' builtin function. -- -- The ARGUMENTS are the arguments of the function. They are separated --from the function name by one or more spaces or tabs, and if there is --more than one argument, then they are separated by commas. Such --whitespace and commas are not part of an argument's value. The --delimiters which you use to surround the function call, whether --parentheses or braces, can appear in an argument only in matching pairs; --the other kind of delimiters may appear singly. If the arguments --themselves contain other function calls or variable references, it is --wisest to use the same kind of delimiters for all the references; write --`$(subst a,b,$(x))', not `$(subst a,b,${x})'. This is because it is --clearer, and because only one type of delimiter is matched to find the --end of the reference. -- -- The text written for each argument is processed by substitution of --variables and function calls to produce the argument value, which is --the text on which the function acts. The substitution is done in the --order in which the arguments appear. -- -- Commas and unmatched parentheses or braces cannot appear in the text --of an argument as written; leading spaces cannot appear in the text of --the first argument as written. These characters can be put into the --argument value by variable substitution. First define variables --`comma' and `space' whose values are isolated comma and space --characters, then substitute these variables where such characters are --wanted, like this: -- -- comma:= , -- empty:= -- space:= $(empty) $(empty) -- foo:= a b c -- bar:= $(subst $(space),$(comma),$(foo)) -- # bar is now `a,b,c'. -- --Here the `subst' function replaces each space with a comma, through the --value of `foo', and substitutes the result. -- -- --File: make.info, Node: Text Functions, Next: File Name Functions, Prev: Syntax of Functions, Up: Functions -- --8.2 Functions for String Substitution and Analysis --================================================== -- --Here are some functions that operate on strings: -- --`$(subst FROM,TO,TEXT)' -- Performs a textual replacement on the text TEXT: each occurrence -- of FROM is replaced by TO. The result is substituted for the -- function call. For example, -- -- $(subst ee,EE,feet on the street) -- -- substitutes the string `fEEt on the strEEt'. -- --`$(patsubst PATTERN,REPLACEMENT,TEXT)' -- Finds whitespace-separated words in TEXT that match PATTERN and -- replaces them with REPLACEMENT. Here PATTERN may contain a `%' -- which acts as a wildcard, matching any number of any characters -- within a word. If REPLACEMENT also contains a `%', the `%' is -- replaced by the text that matched the `%' in PATTERN. Only the -- first `%' in the PATTERN and REPLACEMENT is treated this way; any -- subsequent `%' is unchanged. -- -- `%' characters in `patsubst' function invocations can be quoted -- with preceding backslashes (`\'). Backslashes that would -- otherwise quote `%' characters can be quoted with more backslashes. -- Backslashes that quote `%' characters or other backslashes are -- removed from the pattern before it is compared file names or has a -- stem substituted into it. Backslashes that are not in danger of -- quoting `%' characters go unmolested. For example, the pattern -- `the\%weird\\%pattern\\' has `the%weird\' preceding the operative -- `%' character, and `pattern\\' following it. The final two -- backslashes are left alone because they cannot affect any `%' -- character. -- -- Whitespace between words is folded into single space characters; -- leading and trailing whitespace is discarded. -- -- For example, -- -- $(patsubst %.c,%.o,x.c.c bar.c) -- -- produces the value `x.c.o bar.o'. -- -- Substitution references (*note Substitution References: -- Substitution Refs.) are a simpler way to get the effect of the -- `patsubst' function: -- -- $(VAR:PATTERN=REPLACEMENT) -- -- is equivalent to -- -- $(patsubst PATTERN,REPLACEMENT,$(VAR)) -- -- The second shorthand simplifies one of the most common uses of -- `patsubst': replacing the suffix at the end of file names. -- -- $(VAR:SUFFIX=REPLACEMENT) -- -- is equivalent to -- -- $(patsubst %SUFFIX,%REPLACEMENT,$(VAR)) -- -- For example, you might have a list of object files: -- -- objects = foo.o bar.o baz.o -- -- To get the list of corresponding source files, you could simply -- write: -- -- $(objects:.o=.c) -- -- instead of using the general form: -- -- $(patsubst %.o,%.c,$(objects)) -- --`$(strip STRING)' -- Removes leading and trailing whitespace from STRING and replaces -- each internal sequence of one or more whitespace characters with a -- single space. Thus, `$(strip a b c )' results in `a b c'. -- -- The function `strip' can be very useful when used in conjunction -- with conditionals. When comparing something with the empty string -- `' using `ifeq' or `ifneq', you usually want a string of just -- whitespace to match the empty string (*note Conditionals::). -- -- Thus, the following may fail to have the desired results: -- -- .PHONY: all -- ifneq "$(needs_made)" "" -- all: $(needs_made) -- else -- all:;@echo 'Nothing to make!' -- endif -- -- Replacing the variable reference `$(needs_made)' with the function -- call `$(strip $(needs_made))' in the `ifneq' directive would make -- it more robust. -- --`$(findstring FIND,IN)' -- Searches IN for an occurrence of FIND. If it occurs, the value is -- FIND; otherwise, the value is empty. You can use this function in -- a conditional to test for the presence of a specific substring in -- a given string. Thus, the two examples, -- -- $(findstring a,a b c) -- $(findstring a,b c) -- -- produce the values `a' and `' (the empty string), respectively. -- *Note Testing Flags::, for a practical application of `findstring'. -- --`$(filter PATTERN...,TEXT)' -- Returns all whitespace-separated words in TEXT that _do_ match any -- of the PATTERN words, removing any words that _do not_ match. The -- patterns are written using `%', just like the patterns used in the -- `patsubst' function above. -- -- The `filter' function can be used to separate out different types -- of strings (such as file names) in a variable. For example: -- -- sources := foo.c bar.c baz.s ugh.h -- foo: $(sources) -- cc $(filter %.c %.s,$(sources)) -o foo -- -- says that `foo' depends of `foo.c', `bar.c', `baz.s' and `ugh.h' -- but only `foo.c', `bar.c' and `baz.s' should be specified in the -- command to the compiler. -- --`$(filter-out PATTERN...,TEXT)' -- Returns all whitespace-separated words in TEXT that _do not_ match -- any of the PATTERN words, removing the words that _do_ match one -- or more. This is the exact opposite of the `filter' function. -- -- For example, given: -- -- objects=main1.o foo.o main2.o bar.o -- mains=main1.o main2.o -- -- the following generates a list which contains all the object files -- not in `mains': -- -- $(filter-out $(mains),$(objects)) -- --`$(sort LIST)' -- Sorts the words of LIST in lexical order, removing duplicate -- words. The output is a list of words separated by single spaces. -- Thus, -- -- $(sort foo bar lose) -- -- returns the value `bar foo lose'. -- -- Incidentally, since `sort' removes duplicate words, you can use it -- for this purpose even if you don't care about the sort order. -- --`$(word N,TEXT)' -- Returns the Nth word of TEXT. The legitimate values of N start -- from 1. If N is bigger than the number of words in TEXT, the -- value is empty. For example, -- -- $(word 2, foo bar baz) -- -- returns `bar'. -- --`$(wordlist S,E,TEXT)' -- Returns the list of words in TEXT starting with word S and ending -- with word E (inclusive). The legitimate values of S start from 1; -- E may start from 0. If S is bigger than the number of words in -- TEXT, the value is empty. If E is bigger than the number of words -- in TEXT, words up to the end of TEXT are returned. If S is -- greater than E, nothing is returned. For example, -- -- $(wordlist 2, 3, foo bar baz) -- -- returns `bar baz'. -- --`$(words TEXT)' -- Returns the number of words in TEXT. Thus, the last word of TEXT -- is `$(word $(words TEXT),TEXT)'. -- --`$(firstword NAMES...)' -- The argument NAMES is regarded as a series of names, separated by -- whitespace. The value is the first name in the series. The rest -- of the names are ignored. -- -- For example, -- -- $(firstword foo bar) -- -- produces the result `foo'. Although `$(firstword TEXT)' is the -- same as `$(word 1,TEXT)', the `firstword' function is retained for -- its simplicity. -- --`$(lastword NAMES...)' -- The argument NAMES is regarded as a series of names, separated by -- whitespace. The value is the last name in the series. -- -- For example, -- -- $(lastword foo bar) -- -- produces the result `bar'. Although `$(lastword TEXT)' is the -- same as `$(word $(words TEXT),TEXT)', the `lastword' function was -- added for its simplicity and better performance. -- -- Here is a realistic example of the use of `subst' and `patsubst'. --Suppose that a makefile uses the `VPATH' variable to specify a list of --directories that `make' should search for prerequisite files (*note --`VPATH' Search Path for All Prerequisites: General Search.). This --example shows how to tell the C compiler to search for header files in --the same list of directories. -- -- The value of `VPATH' is a list of directories separated by colons, --such as `src:../headers'. First, the `subst' function is used to --change the colons to spaces: -- -- $(subst :, ,$(VPATH)) -- --This produces `src ../headers'. Then `patsubst' is used to turn each --directory name into a `-I' flag. These can be added to the value of --the variable `CFLAGS', which is passed automatically to the C compiler, --like this: -- -- override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH))) -- --The effect is to append the text `-Isrc -I../headers' to the previously --given value of `CFLAGS'. The `override' directive is used so that the --new value is assigned even if the previous value of `CFLAGS' was --specified with a command argument (*note The `override' Directive: --Override Directive.). -- -- --File: make.info, Node: File Name Functions, Next: Conditional Functions, Prev: Text Functions, Up: Functions -- --8.3 Functions for File Names --============================ -- --Several of the built-in expansion functions relate specifically to --taking apart file names or lists of file names. -- -- Each of the following functions performs a specific transformation --on a file name. The argument of the function is regarded as a series --of file names, separated by whitespace. (Leading and trailing --whitespace is ignored.) Each file name in the series is transformed in --the same way and the results are concatenated with single spaces --between them. -- --`$(dir NAMES...)' -- Extracts the directory-part of each file name in NAMES. The -- directory-part of the file name is everything up through (and -- including) the last slash in it. If the file name contains no -- slash, the directory part is the string `./'. For example, -- -- $(dir src/foo.c hacks) -- -- produces the result `src/ ./'. -- --`$(notdir NAMES...)' -- Extracts all but the directory-part of each file name in NAMES. -- If the file name contains no slash, it is left unchanged. -- Otherwise, everything through the last slash is removed from it. -- -- A file name that ends with a slash becomes an empty string. This -- is unfortunate, because it means that the result does not always -- have the same number of whitespace-separated file names as the -- argument had; but we do not see any other valid alternative. -- -- For example, -- -- $(notdir src/foo.c hacks) -- -- produces the result `foo.c hacks'. -- --`$(suffix NAMES...)' -- Extracts the suffix of each file name in NAMES. If the file name -- contains a period, the suffix is everything starting with the last -- period. Otherwise, the suffix is the empty string. This -- frequently means that the result will be empty when NAMES is not, -- and if NAMES contains multiple file names, the result may contain -- fewer file names. -- -- For example, -- -- $(suffix src/foo.c src-1.0/bar.c hacks) -- -- produces the result `.c .c'. -- --`$(basename NAMES...)' -- Extracts all but the suffix of each file name in NAMES. If the -- file name contains a period, the basename is everything starting -- up to (and not including) the last period. Periods in the -- directory part are ignored. If there is no period, the basename -- is the entire file name. For example, -- -- $(basename src/foo.c src-1.0/bar hacks) -- -- produces the result `src/foo src-1.0/bar hacks'. -- --`$(addsuffix SUFFIX,NAMES...)' -- The argument NAMES is regarded as a series of names, separated by -- whitespace; SUFFIX is used as a unit. The value of SUFFIX is -- appended to the end of each individual name and the resulting -- larger names are concatenated with single spaces between them. -- For example, -- -- $(addsuffix .c,foo bar) -- -- produces the result `foo.c bar.c'. -- --`$(addprefix PREFIX,NAMES...)' -- The argument NAMES is regarded as a series of names, separated by -- whitespace; PREFIX is used as a unit. The value of PREFIX is -- prepended to the front of each individual name and the resulting -- larger names are concatenated with single spaces between them. -- For example, -- -- $(addprefix src/,foo bar) -- -- produces the result `src/foo src/bar'. -- --`$(join LIST1,LIST2)' -- Concatenates the two arguments word by word: the two first words -- (one from each argument) concatenated form the first word of the -- result, the two second words form the second word of the result, -- and so on. So the Nth word of the result comes from the Nth word -- of each argument. If one argument has more words that the other, -- the extra words are copied unchanged into the result. -- -- For example, `$(join a b,.c .o)' produces `a.c b.o'. -- -- Whitespace between the words in the lists is not preserved; it is -- replaced with a single space. -- -- This function can merge the results of the `dir' and `notdir' -- functions, to produce the original list of files which was given -- to those two functions. -- --`$(wildcard PATTERN)' -- The argument PATTERN is a file name pattern, typically containing -- wildcard characters (as in shell file name patterns). The result -- of `wildcard' is a space-separated list of the names of existing -- files that match the pattern. *Note Using Wildcard Characters in -- File Names: Wildcards. -- --`$(realpath NAMES...)' -- For each file name in NAMES return the canonical absolute name. A -- canonical name does not contain any `.' or `..' components, nor -- any repeated path separators (`/') or symlinks. In case of a -- failure the empty string is returned. Consult the `realpath(3)' -- documentation for a list of possible failure causes. -- --`$(abspath NAMES...)' -- For each file name in NAMES return an absolute name that does not -- contain any `.' or `..' components, nor any repeated path -- separators (`/'). Note that, in contrast to `realpath' function, -- `abspath' does not resolve symlinks and does not require the file -- names to refer to an existing file or directory. Use the -- `wildcard' function to test for existence. -- -- --File: make.info, Node: Conditional Functions, Next: Foreach Function, Prev: File Name Functions, Up: Functions -- --8.4 Functions for Conditionals --============================== -- --There are three functions that provide conditional expansion. A key --aspect of these functions is that not all of the arguments are expanded --initially. Only those arguments which need to be expanded, will be --expanded. -- --`$(if CONDITION,THEN-PART[,ELSE-PART])' -- The `if' function provides support for conditional expansion in a -- functional context (as opposed to the GNU `make' makefile -- conditionals such as `ifeq' (*note Syntax of Conditionals: -- Conditional Syntax.). -- -- The first argument, CONDITION, first has all preceding and -- trailing whitespace stripped, then is expanded. If it expands to -- any non-empty string, then the condition is considered to be true. -- If it expands to an empty string, the condition is considered to -- be false. -- -- If the condition is true then the second argument, THEN-PART, is -- evaluated and this is used as the result of the evaluation of the -- entire `if' function. -- -- If the condition is false then the third argument, ELSE-PART, is -- evaluated and this is the result of the `if' function. If there is -- no third argument, the `if' function evaluates to nothing (the -- empty string). -- -- Note that only one of the THEN-PART or the ELSE-PART will be -- evaluated, never both. Thus, either can contain side-effects -- (such as `shell' function calls, etc.) -- --`$(or CONDITION1[,CONDITION2[,CONDITION3...]])' -- The `or' function provides a "short-circuiting" OR operation. -- Each argument is expanded, in order. If an argument expands to a -- non-empty string the processing stops and the result of the -- expansion is that string. If, after all arguments are expanded, -- all of them are false (empty), then the result of the expansion is -- the empty string. -- --`$(and CONDITION1[,CONDITION2[,CONDITION3...]])' -- The `and' function provides a "short-circuiting" AND operation. -- Each argument is expanded, in order. If an argument expands to an -- empty string the processing stops and the result of the expansion -- is the empty string. If all arguments expand to a non-empty -- string then the result of the expansion is the expansion of the -- last argument. -- -- -- --File: make.info, Node: Foreach Function, Next: Call Function, Prev: Conditional Functions, Up: Functions -- --8.5 The `foreach' Function --========================== -- --The `foreach' function is very different from other functions. It --causes one piece of text to be used repeatedly, each time with a --different substitution performed on it. It resembles the `for' command --in the shell `sh' and the `foreach' command in the C-shell `csh'. -- -- The syntax of the `foreach' function is: -- -- $(foreach VAR,LIST,TEXT) -- --The first two arguments, VAR and LIST, are expanded before anything --else is done; note that the last argument, TEXT, is *not* expanded at --the same time. Then for each word of the expanded value of LIST, the --variable named by the expanded value of VAR is set to that word, and --TEXT is expanded. Presumably TEXT contains references to that --variable, so its expansion will be different each time. -- -- The result is that TEXT is expanded as many times as there are --whitespace-separated words in LIST. The multiple expansions of TEXT --are concatenated, with spaces between them, to make the result of --`foreach'. -- -- This simple example sets the variable `files' to the list of all --files in the directories in the list `dirs': -- -- dirs := a b c d -- files := $(foreach dir,$(dirs),$(wildcard $(dir)/*)) -- -- Here TEXT is `$(wildcard $(dir)/*)'. The first repetition finds the --value `a' for `dir', so it produces the same result as `$(wildcard --a/*)'; the second repetition produces the result of `$(wildcard b/*)'; --and the third, that of `$(wildcard c/*)'. -- -- This example has the same result (except for setting `dirs') as the --following example: -- -- files := $(wildcard a/* b/* c/* d/*) -- -- When TEXT is complicated, you can improve readability by giving it a --name, with an additional variable: -- -- find_files = $(wildcard $(dir)/*) -- dirs := a b c d -- files := $(foreach dir,$(dirs),$(find_files)) -- --Here we use the variable `find_files' this way. We use plain `=' to --define a recursively-expanding variable, so that its value contains an --actual function call to be reexpanded under the control of `foreach'; a --simply-expanded variable would not do, since `wildcard' would be called --only once at the time of defining `find_files'. -- -- The `foreach' function has no permanent effect on the variable VAR; --its value and flavor after the `foreach' function call are the same as --they were beforehand. The other values which are taken from LIST are --in effect only temporarily, during the execution of `foreach'. The --variable VAR is a simply-expanded variable during the execution of --`foreach'. If VAR was undefined before the `foreach' function call, it --is undefined after the call. *Note The Two Flavors of Variables: --Flavors. -- -- You must take care when using complex variable expressions that --result in variable names because many strange things are valid variable --names, but are probably not what you intended. For example, -- -- files := $(foreach Esta escrito en espanol!,b c ch,$(find_files)) -- --might be useful if the value of `find_files' references the variable --whose name is `Esta escrito en espanol!' (es un nombre bastante largo, --no?), but it is more likely to be a mistake. -- -- --File: make.info, Node: Call Function, Next: Value Function, Prev: Foreach Function, Up: Functions -- --8.6 The `call' Function --======================= -- --The `call' function is unique in that it can be used to create new --parameterized functions. You can write a complex expression as the --value of a variable, then use `call' to expand it with different values. -- -- The syntax of the `call' function is: -- -- $(call VARIABLE,PARAM,PARAM,...) -- -- When `make' expands this function, it assigns each PARAM to --temporary variables `$(1)', `$(2)', etc. The variable `$(0)' will --contain VARIABLE. There is no maximum number of parameter arguments. --There is no minimum, either, but it doesn't make sense to use `call' --with no parameters. -- -- Then VARIABLE is expanded as a `make' variable in the context of --these temporary assignments. Thus, any reference to `$(1)' in the --value of VARIABLE will resolve to the first PARAM in the invocation of --`call'. -- -- Note that VARIABLE is the _name_ of a variable, not a _reference_ to --that variable. Therefore you would not normally use a `$' or --parentheses when writing it. (You can, however, use a variable --reference in the name if you want the name not to be a constant.) -- -- If VARIABLE is the name of a builtin function, the builtin function --is always invoked (even if a `make' variable by that name also exists). -- -- The `call' function expands the PARAM arguments before assigning --them to temporary variables. This means that VARIABLE values --containing references to builtin functions that have special expansion --rules, like `foreach' or `if', may not work as you expect. -- -- Some examples may make this clearer. -- -- This macro simply reverses its arguments: -- -- reverse = $(2) $(1) -- -- foo = $(call reverse,a,b) -- --Here FOO will contain `b a'. -- -- This one is slightly more interesting: it defines a macro to search --for the first instance of a program in `PATH': -- -- pathsearch = $(firstword $(wildcard $(addsuffix /$(1),$(subst :, ,$(PATH))))) -- -- LS := $(call pathsearch,ls) -- --Now the variable LS contains `/bin/ls' or similar. -- -- The `call' function can be nested. Each recursive invocation gets --its own local values for `$(1)', etc. that mask the values of --higher-level `call'. For example, here is an implementation of a "map" --function: -- -- map = $(foreach a,$(2),$(call $(1),$(a))) -- -- Now you can MAP a function that normally takes only one argument, --such as `origin', to multiple values in one step: -- -- o = $(call map,origin,o map MAKE) -- -- and end up with O containing something like `file file default'. -- -- A final caution: be careful when adding whitespace to the arguments --to `call'. As with other functions, any whitespace contained in the --second and subsequent arguments is kept; this can cause strange --effects. It's generally safest to remove all extraneous whitespace when --providing parameters to `call'. -- -- --File: make.info, Node: Value Function, Next: Eval Function, Prev: Call Function, Up: Functions -- --8.7 The `value' Function --======================== -- --The `value' function provides a way for you to use the value of a --variable _without_ having it expanded. Please note that this does not --undo expansions which have already occurred; for example if you create --a simply expanded variable its value is expanded during the definition; --in that case the `value' function will return the same result as using --the variable directly. -- -- The syntax of the `value' function is: -- -- $(value VARIABLE) -- -- Note that VARIABLE is the _name_ of a variable; not a _reference_ to --that variable. Therefore you would not normally use a `$' or --parentheses when writing it. (You can, however, use a variable --reference in the name if you want the name not to be a constant.) -- -- The result of this function is a string containing the value of --VARIABLE, without any expansion occurring. For example, in this --makefile: -- -- FOO = $PATH -- -- all: -- @echo $(FOO) -- @echo $(value FOO) -- --The first output line would be `ATH', since the "$P" would be expanded --as a `make' variable, while the second output line would be the current --value of your `$PATH' environment variable, since the `value' function --avoided the expansion. -- -- The `value' function is most often used in conjunction with the --`eval' function (*note Eval Function::). -- -- --File: make.info, Node: Eval Function, Next: Origin Function, Prev: Value Function, Up: Functions -- --8.8 The `eval' Function --======================= -- --The `eval' function is very special: it allows you to define new --makefile constructs that are not constant; which are the result of --evaluating other variables and functions. The argument to the `eval' --function is expanded, then the results of that expansion are parsed as --makefile syntax. The expanded results can define new `make' variables, --targets, implicit or explicit rules, etc. -- -- The result of the `eval' function is always the empty string; thus, --it can be placed virtually anywhere in a makefile without causing --syntax errors. -- -- It's important to realize that the `eval' argument is expanded --_twice_; first by the `eval' function, then the results of that --expansion are expanded again when they are parsed as makefile syntax. --This means you may need to provide extra levels of escaping for "$" --characters when using `eval'. The `value' function (*note Value --Function::) can sometimes be useful in these situations, to circumvent --unwanted expansions. -- -- Here is an example of how `eval' can be used; this example combines --a number of concepts and other functions. Although it might seem --overly complex to use `eval' in this example, rather than just writing --out the rules, consider two things: first, the template definition (in --`PROGRAM_template') could need to be much more complex than it is here; --and second, you might put the complex, "generic" part of this example --into another makefile, then include it in all the individual makefiles. --Now your individual makefiles are quite straightforward. -- -- PROGRAMS = server client -- -- server_OBJS = server.o server_priv.o server_access.o -- server_LIBS = priv protocol -- -- client_OBJS = client.o client_api.o client_mem.o -- client_LIBS = protocol -- -- # Everything after this is generic -- -- .PHONY: all -- all: $(PROGRAMS) -- -- define PROGRAM_template -- $(1): $$($(1)_OBJS) $$($(1)_LIBS:%=-l%) -- ALL_OBJS += $$($(1)_OBJS) -- endef -- -- $(foreach prog,$(PROGRAMS),$(eval $(call PROGRAM_template,$(prog)))) -- -- $(PROGRAMS): -- $(LINK.o) $^ $(LDLIBS) -o $@ -- -- clean: -- rm -f $(ALL_OBJS) $(PROGRAMS) -- -- --File: make.info, Node: Origin Function, Next: Flavor Function, Prev: Eval Function, Up: Functions -- --8.9 The `origin' Function --========================= -- --The `origin' function is unlike most other functions in that it does --not operate on the values of variables; it tells you something _about_ --a variable. Specifically, it tells you where it came from. -- -- The syntax of the `origin' function is: -- -- $(origin VARIABLE) -- -- Note that VARIABLE is the _name_ of a variable to inquire about; not --a _reference_ to that variable. Therefore you would not normally use a --`$' or parentheses when writing it. (You can, however, use a variable --reference in the name if you want the name not to be a constant.) -- -- The result of this function is a string telling you how the variable --VARIABLE was defined: -- --`undefined' -- if VARIABLE was never defined. -- --`default' -- if VARIABLE has a default definition, as is usual with `CC' and so -- on. *Note Variables Used by Implicit Rules: Implicit Variables. -- Note that if you have redefined a default variable, the `origin' -- function will return the origin of the later definition. -- --`environment' -- if VARIABLE was defined as an environment variable and the `-e' -- option is _not_ turned on (*note Summary of Options: Options -- Summary.). -- --`environment override' -- if VARIABLE was defined as an environment variable and the `-e' -- option _is_ turned on (*note Summary of Options: Options Summary.). -- --`file' -- if VARIABLE was defined in a makefile. -- --`command line' -- if VARIABLE was defined on the command line. -- --`override' -- if VARIABLE was defined with an `override' directive in a makefile -- (*note The `override' Directive: Override Directive.). -- --`automatic' -- if VARIABLE is an automatic variable defined for the execution of -- the commands for each rule (*note Automatic Variables::). -- -- This information is primarily useful (other than for your curiosity) --to determine if you want to believe the value of a variable. For --example, suppose you have a makefile `foo' that includes another --makefile `bar'. You want a variable `bletch' to be defined in `bar' if --you run the command `make -f bar', even if the environment contains a --definition of `bletch'. However, if `foo' defined `bletch' before --including `bar', you do not want to override that definition. This --could be done by using an `override' directive in `foo', giving that --definition precedence over the later definition in `bar'; --unfortunately, the `override' directive would also override any command --line definitions. So, `bar' could include: -- -- ifdef bletch -- ifeq "$(origin bletch)" "environment" -- bletch = barf, gag, etc. -- endif -- endif -- --If `bletch' has been defined from the environment, this will redefine --it. -- -- If you want to override a previous definition of `bletch' if it came --from the environment, even under `-e', you could instead write: -- -- ifneq "$(findstring environment,$(origin bletch))" "" -- bletch = barf, gag, etc. -- endif -- -- Here the redefinition takes place if `$(origin bletch)' returns --either `environment' or `environment override'. *Note Functions for --String Substitution and Analysis: Text Functions. -- -- --File: make.info, Node: Flavor Function, Next: Shell Function, Prev: Origin Function, Up: Functions -- --8.10 The `flavor' Function --========================== -- --The `flavor' function is unlike most other functions (and like `origin' --function) in that it does not operate on the values of variables; it --tells you something _about_ a variable. Specifically, it tells you the --flavor of a variable (*note The Two Flavors of Variables: Flavors.). -- -- The syntax of the `flavor' function is: -- -- $(flavor VARIABLE) -- -- Note that VARIABLE is the _name_ of a variable to inquire about; not --a _reference_ to that variable. Therefore you would not normally use a --`$' or parentheses when writing it. (You can, however, use a variable --reference in the name if you want the name not to be a constant.) -- -- The result of this function is a string that identifies the flavor --of the variable VARIABLE: -- --`undefined' -- if VARIABLE was never defined. -- --`recursive' -- if VARIABLE is a recursively expanded variable. -- --`simple' -- if VARIABLE is a simply expanded variable. -- -- -- --File: make.info, Node: Shell Function, Next: Make Control Functions, Prev: Flavor Function, Up: Functions -- --8.11 The `shell' Function --========================= -- --The `shell' function is unlike any other function other than the --`wildcard' function (*note The Function `wildcard': Wildcard Function.) --in that it communicates with the world outside of `make'. -- -- The `shell' function performs the same function that backquotes --(``') perform in most shells: it does "command expansion". This means --that it takes as an argument a shell command and evaluates to the --output of the command. The only processing `make' does on the result --is to convert each newline (or carriage-return / newline pair) to a --single space. If there is a trailing (carriage-return and) newline it --will simply be removed. -- -- The commands run by calls to the `shell' function are run when the --function calls are expanded (*note How `make' Reads a Makefile: Reading --Makefiles.). Because this function involves spawning a new shell, you --should carefully consider the performance implications of using the --`shell' function within recursively expanded variables vs. simply --expanded variables (*note The Two Flavors of Variables: Flavors.). -- -- Here are some examples of the use of the `shell' function: -- -- contents := $(shell cat foo) -- --sets `contents' to the contents of the file `foo', with a space (rather --than a newline) separating each line. -- -- files := $(shell echo *.c) -- --sets `files' to the expansion of `*.c'. Unless `make' is using a very --strange shell, this has the same result as `$(wildcard *.c)' (as long --as at least one `.c' file exists). -- -- --File: make.info, Node: Make Control Functions, Prev: Shell Function, Up: Functions -- --8.12 Functions That Control Make --================================ -- --These functions control the way make runs. Generally, they are used to --provide information to the user of the makefile or to cause make to stop --if some sort of environmental error is detected. -- --`$(error TEXT...)' -- Generates a fatal error where the message is TEXT. Note that the -- error is generated whenever this function is evaluated. So, if -- you put it inside a command script or on the right side of a -- recursive variable assignment, it won't be evaluated until later. -- The TEXT will be expanded before the error is generated. -- -- For example, -- -- ifdef ERROR1 -- $(error error is $(ERROR1)) -- endif -- -- will generate a fatal error during the read of the makefile if the -- `make' variable `ERROR1' is defined. Or, -- -- ERR = $(error found an error!) -- -- .PHONY: err -- err: ; $(ERR) -- -- will generate a fatal error while `make' is running, if the `err' -- target is invoked. -- --`$(warning TEXT...)' -- This function works similarly to the `error' function, above, -- except that `make' doesn't exit. Instead, TEXT is expanded and -- the resulting message is displayed, but processing of the makefile -- continues. -- -- The result of the expansion of this function is the empty string. -- --`$(info TEXT...)' -- This function does nothing more than print its (expanded) -- argument(s) to standard output. No makefile name or line number -- is added. The result of the expansion of this function is the -- empty string. -- -- --File: make.info, Node: Running, Next: Implicit Rules, Prev: Functions, Up: Top -- --9 How to Run `make' --******************* -- --A makefile that says how to recompile a program can be used in more --than one way. The simplest use is to recompile every file that is out --of date. Usually, makefiles are written so that if you run `make' with --no arguments, it does just that. -- -- But you might want to update only some of the files; you might want --to use a different compiler or different compiler options; you might --want just to find out which files are out of date without changing them. -- -- By giving arguments when you run `make', you can do any of these --things and many others. -- -- The exit status of `make' is always one of three values: --`0' -- The exit status is zero if `make' is successful. -- --`2' -- The exit status is two if `make' encounters any errors. It will -- print messages describing the particular errors. -- --`1' -- The exit status is one if you use the `-q' flag and `make' -- determines that some target is not already up to date. *Note -- Instead of Executing the Commands: Instead of Execution. -- --* Menu: -- --* 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 -- -- --File: make.info, Node: Makefile Arguments, Next: Goals, Prev: Running, Up: Running -- --9.1 Arguments to Specify the Makefile --===================================== -- --The way to specify the name of the makefile is with the `-f' or --`--file' option (`--makefile' also works). For example, `-f altmake' --says to use the file `altmake' as the makefile. -- -- If you use the `-f' flag several times and follow each `-f' with an --argument, all the specified files are used jointly as makefiles. -- -- If you do not use the `-f' or `--file' flag, the default is to try --`GNUmakefile', `makefile', and `Makefile', in that order, and use the --first of these three which exists or can be made (*note Writing --Makefiles: Makefiles.). -- -- --File: make.info, Node: Goals, Next: Instead of Execution, Prev: Makefile Arguments, Up: Running -- --9.2 Arguments to Specify the Goals --================================== -- --The "goals" are the targets that `make' should strive ultimately to --update. Other targets are updated as well if they appear as --prerequisites of goals, or prerequisites of prerequisites of goals, etc. -- -- By default, the goal is the first target in the makefile (not --counting targets that start with a period). Therefore, makefiles are --usually written so that the first target is for compiling the entire --program or programs they describe. If the first rule in the makefile --has several targets, only the first target in the rule becomes the --default goal, not the whole list. You can manage the selection of the --default goal from within your makefile using the `.DEFAULT_GOAL' --variable (*note Other Special Variables: Special Variables.). -- -- You can also specify a different goal or goals with command-line --arguments to `make'. Use the name of the goal as an argument. If you --specify several goals, `make' processes each of them in turn, in the --order you name them. -- -- Any target in the makefile may be specified as a goal (unless it --starts with `-' or contains an `=', in which case it will be parsed as --a switch or variable definition, respectively). Even targets not in --the makefile may be specified, if `make' can find implicit rules that --say how to make them. -- -- `Make' will set the special variable `MAKECMDGOALS' to the list of --goals you specified on the command line. If no goals were given on the --command line, this variable is empty. Note that this variable should --be used only in special circumstances. -- -- An example of appropriate use is to avoid including `.d' files --during `clean' rules (*note Automatic Prerequisites::), so `make' won't --create them only to immediately remove them again: -- -- sources = foo.c bar.c -- -- ifneq ($(MAKECMDGOALS),clean) -- include $(sources:.c=.d) -- endif -- -- One use of specifying a goal is if you want to compile only a part of --the program, or only one of several programs. Specify as a goal each --file that you wish to remake. For example, consider a directory --containing several programs, with a makefile that starts like this: -- -- .PHONY: all -- all: size nm ld ar as -- -- If you are working on the program `size', you might want to say --`make size' so that only the files of that program are recompiled. -- -- Another use of specifying a goal is to make files that are not --normally made. For example, there may be a file of debugging output, --or a version of the program that is compiled specially for testing, --which has a rule in the makefile but is not a prerequisite of the --default goal. -- -- Another use of specifying a goal is to run the commands associated --with a phony target (*note Phony Targets::) or empty target (*note --Empty Target Files to Record Events: Empty Targets.). Many makefiles --contain a phony target named `clean' which deletes everything except --source files. Naturally, this is done only if you request it --explicitly with `make clean'. Following is a list of typical phony and --empty target names. *Note Standard Targets::, for a detailed list of --all the standard target names which GNU software packages use. -- --`all' -- Make all the top-level targets the makefile knows about. -- --`clean' -- Delete all files that are normally created by running `make'. -- --`mostlyclean' -- Like `clean', but may refrain from deleting a few files that people -- normally don't want to recompile. For example, the `mostlyclean' -- target for GCC does not delete `libgcc.a', because recompiling it -- is rarely necessary and takes a lot of time. -- --`distclean' --`realclean' --`clobber' -- Any of these targets might be defined to delete _more_ files than -- `clean' does. For example, this would delete configuration files -- or links that you would normally create as preparation for -- compilation, even if the makefile itself cannot create these files. -- --`install' -- Copy the executable file into a directory that users typically -- search for commands; copy any auxiliary files that the executable -- uses into the directories where it will look for them. -- --`print' -- Print listings of the source files that have changed. -- --`tar' -- Create a tar file of the source files. -- --`shar' -- Create a shell archive (shar file) of the source files. -- --`dist' -- Create a distribution file of the source files. This might be a -- tar file, or a shar file, or a compressed version of one of the -- above, or even more than one of the above. -- --`TAGS' -- Update a tags table for this program. -- --`check' --`test' -- Perform self tests on the program this makefile builds. -- -- --File: make.info, Node: Instead of Execution, Next: Avoiding Compilation, Prev: Goals, Up: Running -- --9.3 Instead of Executing the Commands --===================================== -- --The makefile tells `make' how to tell whether a target is up to date, --and how to update each target. But updating the targets is not always --what you want. Certain options specify other activities for `make'. -- --`-n' --`--just-print' --`--dry-run' --`--recon' -- "No-op". The activity is to print what commands would be used to -- make the targets up to date, but not actually execute them. -- --`-t' --`--touch' -- "Touch". The activity is to mark the targets as up to date without -- actually changing them. In other words, `make' pretends to compile -- the targets but does not really change their contents. -- --`-q' --`--question' -- "Question". The activity is to find out silently whether the -- targets are up to date already; but execute no commands in either -- case. In other words, neither compilation nor output will occur. -- --`-W FILE' --`--what-if=FILE' --`--assume-new=FILE' --`--new-file=FILE' -- "What if". Each `-W' flag is followed by a file name. The given -- files' modification times are recorded by `make' as being the -- present time, although the actual modification times remain the -- same. You can use the `-W' flag in conjunction with the `-n' flag -- to see what would happen if you were to modify specific files. -- -- With the `-n' flag, `make' prints the commands that it would --normally execute but does not execute them. -- -- With the `-t' flag, `make' ignores the commands in the rules and --uses (in effect) the command `touch' for each target that needs to be --remade. The `touch' command is also printed, unless `-s' or `.SILENT' --is used. For speed, `make' does not actually invoke the program --`touch'. It does the work directly. -- -- With the `-q' flag, `make' prints nothing and executes no commands, --but the exit status code it returns is zero if and only if the targets --to be considered are already up to date. If the exit status is one, --then some updating needs to be done. If `make' encounters an error, --the exit status is two, so you can distinguish an error from a target --that is not up to date. -- -- It is an error to use more than one of these three flags in the same --invocation of `make'. -- -- The `-n', `-t', and `-q' options do not affect command lines that --begin with `+' characters or contain the strings `$(MAKE)' or --`${MAKE}'. Note that only the line containing the `+' character or the --strings `$(MAKE)' or `${MAKE}' is run regardless of these options. --Other lines in the same rule are not run unless they too begin with `+' --or contain `$(MAKE)' or `${MAKE}' (*Note How the `MAKE' Variable Works: --MAKE Variable.) -- -- The `-W' flag provides two features: -- -- * If you also use the `-n' or `-q' flag, you can see what `make' -- would do if you were to modify some files. -- -- * Without the `-n' or `-q' flag, when `make' is actually executing -- commands, the `-W' flag can direct `make' to act as if some files -- had been modified, without actually modifying the files. -- -- Note that the options `-p' and `-v' allow you to obtain other --information about `make' or about the makefiles in use (*note Summary --of Options: Options Summary.). -- -- --File: make.info, Node: Avoiding Compilation, Next: Overriding, Prev: Instead of Execution, Up: Running -- --9.4 Avoiding Recompilation of Some Files --======================================== -- --Sometimes you may have changed a source file but you do not want to --recompile all the files that depend on it. For example, suppose you add --a macro or a declaration to a header file that many other files depend --on. Being conservative, `make' assumes that any change in the header --file requires recompilation of all dependent files, but you know that --they do not need to be recompiled and you would rather not waste the --time waiting for them to compile. -- -- If you anticipate the problem before changing the header file, you --can use the `-t' flag. This flag tells `make' not to run the commands --in the rules, but rather to mark the target up to date by changing its --last-modification date. You would follow this procedure: -- -- 1. Use the command `make' to recompile the source files that really -- need recompilation, ensuring that the object files are up-to-date -- before you begin. -- -- 2. Make the changes in the header files. -- -- 3. Use the command `make -t' to mark all the object files as up to -- date. The next time you run `make', the changes in the header -- files will not cause any recompilation. -- -- If you have already changed the header file at a time when some files --do need recompilation, it is too late to do this. Instead, you can use --the `-o FILE' flag, which marks a specified file as "old" (*note --Summary of Options: Options Summary.). This means that the file itself --will not be remade, and nothing else will be remade on its account. --Follow this procedure: -- -- 1. Recompile the source files that need compilation for reasons -- independent of the particular header file, with `make -o -- HEADERFILE'. If several header files are involved, use a separate -- `-o' option for each header file. -- -- 2. Touch all the object files with `make -t'. -- -- --File: make.info, Node: Overriding, Next: Testing, Prev: Avoiding Compilation, Up: Running -- --9.5 Overriding Variables --======================== -- --An argument that contains `=' specifies the value of a variable: `V=X' --sets the value of the variable V to X. If you specify a value in this --way, all ordinary assignments of the same variable in the makefile are --ignored; we say they have been "overridden" by the command line --argument. -- -- The most common way to use this facility is to pass extra flags to --compilers. For example, in a properly written makefile, the variable --`CFLAGS' is included in each command that runs the C compiler, so a --file `foo.c' would be compiled something like this: -- -- cc -c $(CFLAGS) foo.c -- -- Thus, whatever value you set for `CFLAGS' affects each compilation --that occurs. The makefile probably specifies the usual value for --`CFLAGS', like this: -- -- CFLAGS=-g -- -- Each time you run `make', you can override this value if you wish. --For example, if you say `make CFLAGS='-g -O'', each C compilation will --be done with `cc -c -g -O'. (This also illustrates how you can use --quoting in the shell to enclose spaces and other special characters in --the value of a variable when you override it.) -- -- The variable `CFLAGS' is only one of many standard variables that --exist just so that you can change them this way. *Note Variables Used --by Implicit Rules: Implicit Variables, for a complete list. -- -- You can also program the makefile to look at additional variables of --your own, giving the user the ability to control other aspects of how --the makefile works by changing the variables. -- -- When you override a variable with a command argument, you can define --either a recursively-expanded variable or a simply-expanded variable. --The examples shown above make a recursively-expanded variable; to make a --simply-expanded variable, write `:=' instead of `='. But, unless you --want to include a variable reference or function call in the _value_ --that you specify, it makes no difference which kind of variable you --create. -- -- There is one way that the makefile can change a variable that you --have overridden. This is to use the `override' directive, which is a --line that looks like this: `override VARIABLE = VALUE' (*note The --`override' Directive: Override Directive.). -- -- --File: make.info, Node: Testing, Next: Options Summary, Prev: Overriding, Up: Running -- --9.6 Testing the Compilation of a Program --======================================== -- --Normally, when an error happens in executing a shell command, `make' --gives up immediately, returning a nonzero status. No further commands --are executed for any target. The error implies that the goal cannot be --correctly remade, and `make' reports this as soon as it knows. -- -- When you are compiling a program that you have just changed, this is --not what you want. Instead, you would rather that `make' try compiling --every file that can be tried, to show you as many compilation errors as --possible. -- -- On these occasions, you should use the `-k' or `--keep-going' flag. --This tells `make' to continue to consider the other prerequisites of --the pending targets, remaking them if necessary, before it gives up and --returns nonzero status. For example, after an error in compiling one --object file, `make -k' will continue compiling other object files even --though it already knows that linking them will be impossible. In --addition to continuing after failed shell commands, `make -k' will --continue as much as possible after discovering that it does not know --how to make a target or prerequisite file. This will always cause an --error message, but without `-k', it is a fatal error (*note Summary of --Options: Options Summary.). -- -- The usual behavior of `make' assumes that your purpose is to get the --goals up to date; once `make' learns that this is impossible, it might --as well report the failure immediately. The `-k' flag says that the --real purpose is to test as much as possible of the changes made in the --program, perhaps to find several independent problems so that you can --correct them all before the next attempt to compile. This is why Emacs' --`M-x compile' command passes the `-k' flag by default. -- -- --File: make.info, Node: Options Summary, Prev: Testing, Up: Running -- --9.7 Summary of Options --====================== -- --Here is a table of all the options `make' understands: -- --`-b' --`-m' -- These options are ignored for compatibility with other versions of -- `make'. -- --`-B' --`--always-make' -- Consider all targets out-of-date. GNU `make' proceeds to consider -- targets and their prerequisites using the normal algorithms; -- however, all targets so considered are always remade regardless of -- the status of their prerequisites. To avoid infinite recursion, if -- `MAKE_RESTARTS' (*note Other Special Variables: Special -- Variables.) is set to a number greater than 0 this option is -- disabled when considering whether to remake makefiles (*note How -- Makefiles Are Remade: Remaking Makefiles.). -- --`-C DIR' --`--directory=DIR' -- Change to directory DIR before reading the makefiles. If multiple -- `-C' options are specified, each is interpreted relative to the -- previous one: `-C / -C etc' is equivalent to `-C /etc'. This is -- typically used with recursive invocations of `make' (*note -- Recursive Use of `make': Recursion.). -- --`-d' -- Print debugging information in addition to normal processing. The -- debugging information says which files are being considered for -- remaking, which file-times are being compared and with what -- results, which files actually need to be remade, which implicit -- rules are considered and which are applied--everything interesting -- about how `make' decides what to do. The `-d' option is -- equivalent to `--debug=a' (see below). -- --`--debug[=OPTIONS]' -- Print debugging information in addition to normal processing. -- Various levels and types of output can be chosen. With no -- arguments, print the "basic" level of debugging. Possible -- arguments are below; only the first character is considered, and -- values must be comma- or space-separated. -- -- `a (all)' -- All types of debugging output are enabled. This is -- equivalent to using `-d'. -- -- `b (basic)' -- Basic debugging prints each target that was found to be -- out-of-date, and whether the build was successful or not. -- -- `v (verbose)' -- A level above `basic'; includes messages about which -- makefiles were parsed, prerequisites that did not need to be -- rebuilt, etc. This option also enables `basic' messages. -- -- `i (implicit)' -- Prints messages describing the implicit rule searches for -- each target. This option also enables `basic' messages. -- -- `j (jobs)' -- Prints messages giving details on the invocation of specific -- subcommands. -- -- `m (makefile)' -- By default, the above messages are not enabled while trying -- to remake the makefiles. This option enables messages while -- rebuilding makefiles, too. Note that the `all' option does -- enable this option. This option also enables `basic' -- messages. -- --`-e' --`--environment-overrides' -- Give variables taken from the environment precedence over -- variables from makefiles. *Note Variables from the Environment: -- Environment. -- --`-f FILE' --`--file=FILE' --`--makefile=FILE' -- Read the file named FILE as a makefile. *Note Writing Makefiles: -- Makefiles. -- --`-h' --`--help' -- Remind you of the options that `make' understands and then exit. -- --`-i' --`--ignore-errors' -- Ignore all errors in commands executed to remake files. *Note -- Errors in Commands: Errors. -- --`-I DIR' --`--include-dir=DIR' -- Specifies a directory DIR to search for included makefiles. *Note -- Including Other Makefiles: Include. If several `-I' options are -- used to specify several directories, the directories are searched -- in the order specified. -- --`-j [JOBS]' --`--jobs[=JOBS]' -- Specifies the number of jobs (commands) to run simultaneously. -- With no argument, `make' runs as many jobs simultaneously as -- possible. If there is more than one `-j' option, the last one is -- effective. *Note Parallel Execution: Parallel, for more -- information on how commands are run. Note that this option is -- ignored on MS-DOS. -- --`-k' --`--keep-going' -- Continue as much as possible after an error. While the target that -- failed, and those that depend on it, cannot be remade, the other -- prerequisites of these targets can be processed all the same. -- *Note Testing the Compilation of a Program: Testing. -- --`-l [LOAD]' --`--load-average[=LOAD]' --`--max-load[=LOAD]' -- Specifies that no new jobs (commands) should be started if there -- are other jobs running and the load average is at least LOAD (a -- floating-point number). With no argument, removes a previous load -- limit. *Note Parallel Execution: Parallel. -- --`-L' --`--check-symlink-times' -- On systems that support symbolic links, this option causes `make' -- to consider the timestamps on any symbolic links in addition to the -- timestamp on the file referenced by those links. When this option -- is provided, the most recent timestamp among the file and the -- symbolic links is taken as the modification time for this target -- file. -- --`-n' --`--just-print' --`--dry-run' --`--recon' -- Print the commands that would be executed, but do not execute them. -- *Note Instead of Executing the Commands: Instead of Execution. -- --`-o FILE' --`--old-file=FILE' --`--assume-old=FILE' -- Do not remake the file FILE even if it is older than its -- prerequisites, and do not remake anything on account of changes in -- FILE. Essentially the file is treated as very old and its rules -- are ignored. *Note Avoiding Recompilation of Some Files: Avoiding -- Compilation. -- --`-p' --`--print-data-base' -- Print the data base (rules and variable values) that results from -- reading the makefiles; then execute as usual or as otherwise -- specified. This also prints the version information given by the -- `-v' switch (see below). To print the data base without trying to -- remake any files, use `make -qp'. To print the data base of -- predefined rules and variables, use `make -p -f /dev/null'. The -- data base output contains filename and linenumber information for -- command and variable definitions, so it can be a useful debugging -- tool in complex environments. -- --`-q' --`--question' -- "Question mode". Do not run any commands, or print anything; just -- return an exit status that is zero if the specified targets are -- already up to date, one if any remaking is required, or two if an -- error is encountered. *Note Instead of Executing the Commands: -- Instead of Execution. -- --`-r' --`--no-builtin-rules' -- Eliminate use of the built-in implicit rules (*note Using Implicit -- Rules: Implicit Rules.). You can still define your own by writing -- pattern rules (*note Defining and Redefining Pattern Rules: -- Pattern Rules.). The `-r' option also clears out the default list -- of suffixes for suffix rules (*note Old-Fashioned Suffix Rules: -- Suffix Rules.). But you can still define your own suffixes with a -- rule for `.SUFFIXES', and then define your own suffix rules. Note -- that only _rules_ are affected by the `-r' option; default -- variables remain in effect (*note Variables Used by Implicit -- Rules: Implicit Variables.); see the `-R' option below. -- --`-R' --`--no-builtin-variables' -- Eliminate use of the built-in rule-specific variables (*note -- Variables Used by Implicit Rules: Implicit Variables.). You can -- still define your own, of course. The `-R' option also -- automatically enables the `-r' option (see above), since it -- doesn't make sense to have implicit rules without any definitions -- for the variables that they use. -- --`-s' --`--silent' --`--quiet' -- Silent operation; do not print the commands as they are executed. -- *Note Command Echoing: Echoing. -- --`-S' --`--no-keep-going' --`--stop' -- Cancel the effect of the `-k' option. This is never necessary -- except in a recursive `make' where `-k' might be inherited from -- the top-level `make' via `MAKEFLAGS' (*note Recursive Use of -- `make': Recursion.) or if you set `-k' in `MAKEFLAGS' in your -- environment. -- --`-t' --`--touch' -- Touch files (mark them up to date without really changing them) -- instead of running their commands. This is used to pretend that -- the commands were done, in order to fool future invocations of -- `make'. *Note Instead of Executing the Commands: Instead of -- Execution. -- --`-v' --`--version' -- Print the version of the `make' program plus a copyright, a list -- of authors, and a notice that there is no warranty; then exit. -- --`-w' --`--print-directory' -- Print a message containing the working directory both before and -- after executing the makefile. This may be useful for tracking -- down errors from complicated nests of recursive `make' commands. -- *Note Recursive Use of `make': Recursion. (In practice, you -- rarely need to specify this option since `make' does it for you; -- see *Note The `--print-directory' Option: -w Option.) -- --`--no-print-directory' -- Disable printing of the working directory under `-w'. This option -- is useful when `-w' is turned on automatically, but you do not -- want to see the extra messages. *Note The `--print-directory' -- Option: -w Option. -- --`-W FILE' --`--what-if=FILE' --`--new-file=FILE' --`--assume-new=FILE' -- Pretend that the target FILE has just been modified. When used -- with the `-n' flag, this shows you what would happen if you were -- to modify that file. Without `-n', it is almost the same as -- running a `touch' command on the given file before running `make', -- except that the modification time is changed only in the -- imagination of `make'. *Note Instead of Executing the Commands: -- Instead of Execution. -- --`--warn-undefined-variables' -- Issue a warning message whenever `make' sees a reference to an -- undefined variable. This can be helpful when you are trying to -- debug makefiles which use variables in complex ways. -- -- --File: make.info, Node: Implicit Rules, Next: Archives, Prev: Running, Up: Top -- --10 Using Implicit Rules --*********************** -- --Certain standard ways of remaking target files are used very often. For --example, one customary way to make an object file is from a C source --file using the C compiler, `cc'. -- -- "Implicit rules" tell `make' how to use customary techniques so that --you do not have to specify them in detail when you want to use them. --For example, there is an implicit rule for C compilation. File names --determine which implicit rules are run. For example, C compilation --typically takes a `.c' file and makes a `.o' file. So `make' applies --the implicit rule for C compilation when it sees this combination of --file name endings. -- -- A chain of implicit rules can apply in sequence; for example, `make' --will remake a `.o' file from a `.y' file by way of a `.c' file. -- -- The built-in implicit rules use several variables in their commands --so that, by changing the values of the variables, you can change the --way the implicit rule works. For example, the variable `CFLAGS' --controls the flags given to the C compiler by the implicit rule for C --compilation. -- -- You can define your own implicit rules by writing "pattern rules". -- -- "Suffix rules" are a more limited way to define implicit rules. --Pattern rules are more general and clearer, but suffix rules are --retained for compatibility. -- --* Menu: -- --* 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 define commands for rules which -- cannot find any. --* Suffix Rules:: The old-fashioned style of implicit rule. --* Implicit Rule Search:: The precise algorithm for applying -- implicit rules. -- -- --File: make.info, Node: Using Implicit, Next: Catalogue of Rules, Prev: Implicit Rules, Up: Implicit Rules -- --10.1 Using Implicit Rules --========================= -- --To allow `make' to find a customary method for updating a target file, --all you have to do is refrain from specifying commands yourself. Either --write a rule with no command lines, or don't write a rule at all. Then --`make' will figure out which implicit rule to use based on which kind --of source file exists or can be made. -- -- For example, suppose the makefile looks like this: -- -- foo : foo.o bar.o -- cc -o foo foo.o bar.o $(CFLAGS) $(LDFLAGS) -- --Because you mention `foo.o' but do not give a rule for it, `make' will --automatically look for an implicit rule that tells how to update it. --This happens whether or not the file `foo.o' currently exists. -- -- If an implicit rule is found, it can supply both commands and one or --more prerequisites (the source files). You would want to write a rule --for `foo.o' with no command lines if you need to specify additional --prerequisites, such as header files, that the implicit rule cannot --supply. -- -- Each implicit rule has a target pattern and prerequisite patterns. --There may be many implicit rules with the same target pattern. For --example, numerous rules make `.o' files: one, from a `.c' file with the --C compiler; another, from a `.p' file with the Pascal compiler; and so --on. The rule that actually applies is the one whose prerequisites --exist or can be made. So, if you have a file `foo.c', `make' will run --the C compiler; otherwise, if you have a file `foo.p', `make' will run --the Pascal compiler; and so on. -- -- Of course, when you write the makefile, you know which implicit rule --you want `make' to use, and you know it will choose that one because you --know which possible prerequisite files are supposed to exist. *Note --Catalogue of Implicit Rules: Catalogue of Rules, for a catalogue of all --the predefined implicit rules. -- -- Above, we said an implicit rule applies if the required --prerequisites "exist or can be made". A file "can be made" if it is --mentioned explicitly in the makefile as a target or a prerequisite, or --if an implicit rule can be recursively found for how to make it. When --an implicit prerequisite is the result of another implicit rule, we say --that "chaining" is occurring. *Note Chains of Implicit Rules: Chained --Rules. -- -- In general, `make' searches for an implicit rule for each target, and --for each double-colon rule, that has no commands. A file that is --mentioned only as a prerequisite is considered a target whose rule --specifies nothing, so implicit rule search happens for it. *Note --Implicit Rule Search Algorithm: Implicit Rule Search, for the details --of how the search is done. -- -- Note that explicit prerequisites do not influence implicit rule --search. For example, consider this explicit rule: -- -- foo.o: foo.p -- --The prerequisite on `foo.p' does not necessarily mean that `make' will --remake `foo.o' according to the implicit rule to make an object file, a --`.o' file, from a Pascal source file, a `.p' file. For example, if --`foo.c' also exists, the implicit rule to make an object file from a C --source file is used instead, because it appears before the Pascal rule --in the list of predefined implicit rules (*note Catalogue of Implicit --Rules: Catalogue of Rules.). -- -- If you do not want an implicit rule to be used for a target that has --no commands, you can give that target empty commands by writing a --semicolon (*note Defining Empty Commands: Empty Commands.). -- -- --File: make.info, Node: Catalogue of Rules, Next: Implicit Variables, Prev: Using Implicit, Up: Implicit Rules -- --10.2 Catalogue of Implicit Rules --================================ -- --Here is a catalogue of predefined implicit rules which are always --available unless the makefile explicitly overrides or cancels them. --*Note Canceling Implicit Rules: Canceling Rules, for information on --canceling or overriding an implicit rule. The `-r' or --`--no-builtin-rules' option cancels all predefined rules. -- -- This manual only documents the default rules available on POSIX-based --operating systems. Other operating systems, such as VMS, Windows, --OS/2, etc. may have different sets of default rules. To see the full --list of default rules and variables available in your version of GNU --`make', run `make -p' in a directory with no makefile. -- -- Not all of these rules will always be defined, even when the `-r' --option is not given. Many of the predefined implicit rules are --implemented in `make' as suffix rules, so which ones will be defined --depends on the "suffix list" (the list of prerequisites of the special --target `.SUFFIXES'). The default suffix list is: `.out', `.a', `.ln', --`.o', `.c', `.cc', `.C', `.cpp', `.p', `.f', `.F', `.r', `.y', `.l', --`.s', `.S', `.mod', `.sym', `.def', `.h', `.info', `.dvi', `.tex', --`.texinfo', `.texi', `.txinfo', `.w', `.ch' `.web', `.sh', `.elc', --`.el'. All of the implicit rules described below whose prerequisites --have one of these suffixes are actually suffix rules. If you modify --the suffix list, the only predefined suffix rules in effect will be --those named by one or two of the suffixes that are on the list you --specify; rules whose suffixes fail to be on the list are disabled. --*Note Old-Fashioned Suffix Rules: Suffix Rules, for full details on --suffix rules. -- --Compiling C programs -- `N.o' is made automatically from `N.c' with a command of the form -- `$(CC) -c $(CPPFLAGS) $(CFLAGS)'. -- --Compiling C++ programs -- `N.o' is made automatically from `N.cc', `N.cpp', or `N.C' with a -- command of the form `$(CXX) -c $(CPPFLAGS) $(CXXFLAGS)'. We -- encourage you to use the suffix `.cc' for C++ source files instead -- of `.C'. -- --Compiling Pascal programs -- `N.o' is made automatically from `N.p' with the command `$(PC) -c -- $(PFLAGS)'. -- --Compiling Fortran and Ratfor programs -- `N.o' is made automatically from `N.r', `N.F' or `N.f' by running -- the Fortran compiler. The precise command used is as follows: -- -- `.f' -- `$(FC) -c $(FFLAGS)'. -- -- `.F' -- `$(FC) -c $(FFLAGS) $(CPPFLAGS)'. -- -- `.r' -- `$(FC) -c $(FFLAGS) $(RFLAGS)'. -- --Preprocessing Fortran and Ratfor programs -- `N.f' is made automatically from `N.r' or `N.F'. This rule runs -- just the preprocessor to convert a Ratfor or preprocessable -- Fortran program into a strict Fortran program. The precise -- command used is as follows: -- -- `.F' -- `$(FC) -F $(CPPFLAGS) $(FFLAGS)'. -- -- `.r' -- `$(FC) -F $(FFLAGS) $(RFLAGS)'. -- --Compiling Modula-2 programs -- `N.sym' is made from `N.def' with a command of the form `$(M2C) -- $(M2FLAGS) $(DEFFLAGS)'. `N.o' is made from `N.mod'; the form is: -- `$(M2C) $(M2FLAGS) $(MODFLAGS)'. -- --Assembling and preprocessing assembler programs -- `N.o' is made automatically from `N.s' by running the assembler, -- `as'. The precise command is `$(AS) $(ASFLAGS)'. -- -- `N.s' is made automatically from `N.S' by running the C -- preprocessor, `cpp'. The precise command is `$(CPP) $(CPPFLAGS)'. -- --Linking a single object file -- `N' is made automatically from `N.o' by running the linker -- (usually called `ld') via the C compiler. The precise command -- used is `$(CC) $(LDFLAGS) N.o $(LOADLIBES) $(LDLIBS)'. -- -- This rule does the right thing for a simple program with only one -- source file. It will also do the right thing if there are multiple -- object files (presumably coming from various other source files), -- one of which has a name matching that of the executable file. -- Thus, -- -- x: y.o z.o -- -- when `x.c', `y.c' and `z.c' all exist will execute: -- -- cc -c x.c -o x.o -- cc -c y.c -o y.o -- cc -c z.c -o z.o -- cc x.o y.o z.o -o x -- rm -f x.o -- rm -f y.o -- rm -f z.o -- -- In more complicated cases, such as when there is no object file -- whose name derives from the executable file name, you must write -- an explicit command for linking. -- -- Each kind of file automatically made into `.o' object files will -- be automatically linked by using the compiler (`$(CC)', `$(FC)' or -- `$(PC)'; the C compiler `$(CC)' is used to assemble `.s' files) -- without the `-c' option. This could be done by using the `.o' -- object files as intermediates, but it is faster to do the -- compiling and linking in one step, so that's how it's done. -- --Yacc for C programs -- `N.c' is made automatically from `N.y' by running Yacc with the -- command `$(YACC) $(YFLAGS)'. -- --Lex for C programs -- `N.c' is made automatically from `N.l' by running Lex. The actual -- command is `$(LEX) $(LFLAGS)'. -- --Lex for Ratfor programs -- `N.r' is made automatically from `N.l' by running Lex. The actual -- command is `$(LEX) $(LFLAGS)'. -- -- The convention of using the same suffix `.l' for all Lex files -- regardless of whether they produce C code or Ratfor code makes it -- impossible for `make' to determine automatically which of the two -- languages you are using in any particular case. If `make' is -- called upon to remake an object file from a `.l' file, it must -- guess which compiler to use. It will guess the C compiler, because -- that is more common. If you are using Ratfor, make sure `make' -- knows this by mentioning `N.r' in the makefile. Or, if you are -- using Ratfor exclusively, with no C files, remove `.c' from the -- list of implicit rule suffixes with: -- -- .SUFFIXES: -- .SUFFIXES: .o .r .f .l ... -- --Making Lint Libraries from C, Yacc, or Lex programs -- `N.ln' is made from `N.c' by running `lint'. The precise command -- is `$(LINT) $(LINTFLAGS) $(CPPFLAGS) -i'. The same command is -- used on the C code produced from `N.y' or `N.l'. -- --TeX and Web -- `N.dvi' is made from `N.tex' with the command `$(TEX)'. `N.tex' -- is made from `N.web' with `$(WEAVE)', or from `N.w' (and from -- `N.ch' if it exists or can be made) with `$(CWEAVE)'. `N.p' is -- made from `N.web' with `$(TANGLE)' and `N.c' is made from `N.w' -- (and from `N.ch' if it exists or can be made) with `$(CTANGLE)'. -- --Texinfo and Info -- `N.dvi' is made from `N.texinfo', `N.texi', or `N.txinfo', with -- the command `$(TEXI2DVI) $(TEXI2DVI_FLAGS)'. `N.info' is made from -- `N.texinfo', `N.texi', or `N.txinfo', with the command -- `$(MAKEINFO) $(MAKEINFO_FLAGS)'. -- --RCS -- Any file `N' is extracted if necessary from an RCS file named -- either `N,v' or `RCS/N,v'. The precise command used is -- `$(CO) $(COFLAGS)'. `N' will not be extracted from RCS if it -- already exists, even if the RCS file is newer. The rules for RCS -- are terminal (*note Match-Anything Pattern Rules: Match-Anything -- Rules.), so RCS files cannot be generated from another source; -- they must actually exist. -- --SCCS -- Any file `N' is extracted if necessary from an SCCS file named -- either `s.N' or `SCCS/s.N'. The precise command used is -- `$(GET) $(GFLAGS)'. The rules for SCCS are terminal (*note -- Match-Anything Pattern Rules: Match-Anything Rules.), so SCCS -- files cannot be generated from another source; they must actually -- exist. -- -- For the benefit of SCCS, a file `N' is copied from `N.sh' and made -- executable (by everyone). This is for shell scripts that are -- checked into SCCS. Since RCS preserves the execution permission -- of a file, you do not need to use this feature with RCS. -- -- We recommend that you avoid using of SCCS. RCS is widely held to -- be superior, and is also free. By choosing free software in place -- of comparable (or inferior) proprietary software, you support the -- free software movement. -- -- Usually, you want to change only the variables listed in the table --above, which are documented in the following section. -- -- However, the commands in built-in implicit rules actually use --variables such as `COMPILE.c', `LINK.p', and `PREPROCESS.S', whose --values contain the commands listed above. -- -- `make' follows the convention that the rule to compile a `.X' source --file uses the variable `COMPILE.X'. Similarly, the rule to produce an --executable from a `.X' file uses `LINK.X'; and the rule to preprocess a --`.X' file uses `PREPROCESS.X'. -- -- Every rule that produces an object file uses the variable --`OUTPUT_OPTION'. `make' defines this variable either to contain `-o --$@', or to be empty, depending on a compile-time option. You need the --`-o' option to ensure that the output goes into the right file when the --source file is in a different directory, as when using `VPATH' (*note --Directory Search::). However, compilers on some systems do not accept --a `-o' switch for object files. If you use such a system, and use --`VPATH', some compilations will put their output in the wrong place. A --possible workaround for this problem is to give `OUTPUT_OPTION' the --value `; mv $*.o $@'. -- -- --File: make.info, Node: Implicit Variables, Next: Chained Rules, Prev: Catalogue of Rules, Up: Implicit Rules -- --10.3 Variables Used by Implicit Rules --===================================== -- --The commands in built-in implicit rules make liberal use of certain --predefined variables. You can alter the values of these variables in --the makefile, with arguments to `make', or in the environment to alter --how the implicit rules work without redefining the rules themselves. --You can cancel all variables used by implicit rules with the `-R' or --`--no-builtin-variables' option. -- -- For example, the command used to compile a C source file actually --says `$(CC) -c $(CFLAGS) $(CPPFLAGS)'. The default values of the --variables used are `cc' and nothing, resulting in the command `cc -c'. --By redefining `CC' to `ncc', you could cause `ncc' to be used for all C --compilations performed by the implicit rule. By redefining `CFLAGS' to --be `-g', you could pass the `-g' option to each compilation. _All_ --implicit rules that do C compilation use `$(CC)' to get the program --name for the compiler and _all_ include `$(CFLAGS)' among the arguments --given to the compiler. -- -- The variables used in implicit rules fall into two classes: those --that are names of programs (like `CC') and those that contain arguments --for the programs (like `CFLAGS'). (The "name of a program" may also --contain some command arguments, but it must start with an actual --executable program name.) If a variable value contains more than one --argument, separate them with spaces. -- -- The following tables describe of some of the more commonly-used --predefined variables. This list is not exhaustive, and the default --values shown here may not be what are selected by `make' for your --environment. To see the complete list of predefined variables for your --instance of GNU `make' you can run `make -p' in a directory with no --makefiles. -- -- Here is a table of some of the more common variables used as names of --programs in built-in rules: makefiles. -- --`AR' -- Archive-maintaining program; default `ar'. -- --`AS' -- Program for compiling assembly files; default `as'. -- --`CC' -- Program for compiling C programs; default `cc'. -- --`CO' -- Program for checking out files from RCS; default `co'. -- --`CXX' -- Program for compiling C++ programs; default `g++'. -- --`CO' -- Program for extracting a file from RCS; default `co'. -- --`CPP' -- Program for running the C preprocessor, with results to standard -- output; default `$(CC) -E'. -- --`FC' -- Program for compiling or preprocessing Fortran and Ratfor programs; -- default `f77'. -- --`GET' -- Program for extracting a file from SCCS; default `get'. -- --`LEX' -- Program to use to turn Lex grammars into source code; default -- `lex'. -- --`YACC' -- Program to use to turn Yacc grammars into source code; default -- `yacc'. -- --`LINT' -- Program to use to run lint on source code; default `lint'. -- --`M2C' -- Program to use to compile Modula-2 source code; default `m2c'. -- --`PC' -- Program for compiling Pascal programs; default `pc'. -- --`MAKEINFO' -- Program to convert a Texinfo source file into an Info file; default -- `makeinfo'. -- --`TEX' -- Program to make TeX DVI files from TeX source; default `tex'. -- --`TEXI2DVI' -- Program to make TeX DVI files from Texinfo source; default -- `texi2dvi'. -- --`WEAVE' -- Program to translate Web into TeX; default `weave'. -- --`CWEAVE' -- Program to translate C Web into TeX; default `cweave'. -- --`TANGLE' -- Program to translate Web into Pascal; default `tangle'. -- --`CTANGLE' -- Program to translate C Web into C; default `ctangle'. -- --`RM' -- Command to remove a file; default `rm -f'. -- -- Here is a table of variables whose values are additional arguments --for the programs above. The default values for all of these is the --empty string, unless otherwise noted. -- --`ARFLAGS' -- Flags to give the archive-maintaining program; default `rv'. -- --`ASFLAGS' -- Extra flags to give to the assembler (when explicitly invoked on a -- `.s' or `.S' file). -- --`CFLAGS' -- Extra flags to give to the C compiler. -- --`CXXFLAGS' -- Extra flags to give to the C++ compiler. -- --`COFLAGS' -- Extra flags to give to the RCS `co' program. -- --`CPPFLAGS' -- Extra flags to give to the C preprocessor and programs that use it -- (the C and Fortran compilers). -- --`FFLAGS' -- Extra flags to give to the Fortran compiler. -- --`GFLAGS' -- Extra flags to give to the SCCS `get' program. -- --`LDFLAGS' -- Extra flags to give to compilers when they are supposed to invoke -- the linker, `ld'. -- --`LFLAGS' -- Extra flags to give to Lex. -- --`YFLAGS' -- Extra flags to give to Yacc. -- --`PFLAGS' -- Extra flags to give to the Pascal compiler. -- --`RFLAGS' -- Extra flags to give to the Fortran compiler for Ratfor programs. -- --`LINTFLAGS' -- Extra flags to give to lint. -- -- --File: make.info, Node: Chained Rules, Next: Pattern Rules, Prev: Implicit Variables, Up: Implicit Rules -- --10.4 Chains of Implicit Rules --============================= -- --Sometimes a file can be made by a sequence of implicit rules. For --example, a file `N.o' could be made from `N.y' by running first Yacc --and then `cc'. Such a sequence is called a "chain". -- -- If the file `N.c' exists, or is mentioned in the makefile, no --special searching is required: `make' finds that the object file can be --made by C compilation from `N.c'; later on, when considering how to --make `N.c', the rule for running Yacc is used. Ultimately both `N.c' --and `N.o' are updated. -- -- However, even if `N.c' does not exist and is not mentioned, `make' --knows how to envision it as the missing link between `N.o' and `N.y'! --In this case, `N.c' is called an "intermediate file". Once `make' has --decided to use the intermediate file, it is entered in the data base as --if it had been mentioned in the makefile, along with the implicit rule --that says how to create it. -- -- Intermediate files are remade using their rules just like all other --files. But intermediate files are treated differently in two ways. -- -- The first difference is what happens if the intermediate file does --not exist. If an ordinary file B does not exist, and `make' considers --a target that depends on B, it invariably creates B and then updates --the target from B. But if B is an intermediate file, then `make' can --leave well enough alone. It won't bother updating B, or the ultimate --target, unless some prerequisite of B is newer than that target or --there is some other reason to update that target. -- -- The second difference is that if `make' _does_ create B in order to --update something else, it deletes B later on after it is no longer --needed. Therefore, an intermediate file which did not exist before --`make' also does not exist after `make'. `make' reports the deletion --to you by printing a `rm -f' command showing which file it is deleting. -- -- Ordinarily, a file cannot be intermediate if it is mentioned in the --makefile as a target or prerequisite. However, you can explicitly mark --a file as intermediate by listing it as a prerequisite of the special --target `.INTERMEDIATE'. This takes effect even if the file is mentioned --explicitly in some other way. -- -- You can prevent automatic deletion of an intermediate file by --marking it as a "secondary" file. To do this, list it as a --prerequisite of the special target `.SECONDARY'. When a file is --secondary, `make' will not create the file merely because it does not --already exist, but `make' does not automatically delete the file. --Marking a file as secondary also marks it as intermediate. -- -- You can list the target pattern of an implicit rule (such as `%.o') --as a prerequisite of the special target `.PRECIOUS' to preserve --intermediate files made by implicit rules whose target patterns match --that file's name; see *Note Interrupts::. -- -- A chain can involve more than two implicit rules. For example, it is --possible to make a file `foo' from `RCS/foo.y,v' by running RCS, Yacc --and `cc'. Then both `foo.y' and `foo.c' are intermediate files that --are deleted at the end. -- -- No single implicit rule can appear more than once in a chain. This --means that `make' will not even consider such a ridiculous thing as --making `foo' from `foo.o.o' by running the linker twice. This --constraint has the added benefit of preventing any infinite loop in the --search for an implicit rule chain. -- -- There are some special implicit rules to optimize certain cases that --would otherwise be handled by rule chains. For example, making `foo' --from `foo.c' could be handled by compiling and linking with separate --chained rules, using `foo.o' as an intermediate file. But what --actually happens is that a special rule for this case does the --compilation and linking with a single `cc' command. The optimized rule --is used in preference to the step-by-step chain because it comes --earlier in the ordering of rules. -- -diff -rNU3 dist.orig/doc/make.info-2 dist/doc/make.info-2 ---- dist.orig/doc/make.info-2 2006-04-01 08:41:04.000000000 +0200 -+++ dist/doc/make.info-2 1970-01-01 01:00:00.000000000 +0100 -@@ -1,4393 +0,0 @@ --This is make.info, produced by makeinfo version 4.8 from make.texi. -- -- This file documents the GNU `make' utility, which determines --automatically which pieces of a large program need to be recompiled, --and issues the commands to recompile them. -- -- This is Edition 0.70, last updated 1 April 2006, of `The GNU Make --Manual', for GNU `make' version 3.81. -- -- Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, --1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006 Free Software --Foundation, Inc. -- -- Permission is granted to copy, distribute and/or modify this -- document under the terms of the GNU Free Documentation License, -- Version 1.2 or any later version published by the Free Software -- Foundation; with no Invariant Sections, with the Front-Cover Texts -- being "A GNU Manual," and with the Back-Cover Texts as in (a) -- below. A copy of the license is included in the section entitled -- "GNU Free Documentation License." -- -- (a) The FSF's Back-Cover Text is: "You have freedom to copy and -- modify this GNU Manual, like GNU software. Copies published by -- the Free Software Foundation raise funds for GNU development." -- --INFO-DIR-SECTION GNU Packages --START-INFO-DIR-ENTRY --* Make: (make). Remake files automatically. --END-INFO-DIR-ENTRY -- -- --File: make.info, Node: Pattern Rules, Next: Last Resort, Prev: Chained Rules, Up: Implicit Rules -- --10.5 Defining and Redefining Pattern Rules --========================================== -- --You define an implicit rule by writing a "pattern rule". A pattern --rule looks like an ordinary rule, except that its target contains the --character `%' (exactly one of them). The target is considered a --pattern for matching file names; the `%' can match any nonempty --substring, while other characters match only themselves. The --prerequisites likewise use `%' to show how their names relate to the --target name. -- -- Thus, a pattern rule `%.o : %.c' says how to make any file `STEM.o' --from another file `STEM.c'. -- -- Note that expansion using `%' in pattern rules occurs *after* any --variable or function expansions, which take place when the makefile is --read. *Note How to Use Variables: Using Variables, and *Note Functions --for Transforming Text: Functions. -- --* Menu: -- --* Pattern Intro:: An introduction to pattern rules. --* Pattern Examples:: Examples of pattern rules. --* Automatic Variables:: 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. -- -- --File: make.info, Node: Pattern Intro, Next: Pattern Examples, Prev: Pattern Rules, Up: Pattern Rules -- --10.5.1 Introduction to Pattern Rules -------------------------------------- -- --A pattern rule contains the character `%' (exactly one of them) in the --target; otherwise, it looks exactly like an ordinary rule. The target --is a pattern for matching file names; the `%' matches any nonempty --substring, while other characters match only themselves. -- -- For example, `%.c' as a pattern matches any file name that ends in --`.c'. `s.%.c' as a pattern matches any file name that starts with --`s.', ends in `.c' and is at least five characters long. (There must --be at least one character to match the `%'.) The substring that the --`%' matches is called the "stem". -- -- `%' in a prerequisite of a pattern rule stands for the same stem --that was matched by the `%' in the target. In order for the pattern --rule to apply, its target pattern must match the file name under --consideration and all of its prerequisites (after pattern substitution) --must name files that exist or can be made. These files become --prerequisites of the target. -- -- Thus, a rule of the form -- -- %.o : %.c ; COMMAND... -- --specifies how to make a file `N.o', with another file `N.c' as its --prerequisite, provided that `N.c' exists or can be made. -- -- There may also be prerequisites that do not use `%'; such a --prerequisite attaches to every file made by this pattern rule. These --unvarying prerequisites are useful occasionally. -- -- A pattern rule need not have any prerequisites that contain `%', or --in fact any prerequisites at all. Such a rule is effectively a general --wildcard. It provides a way to make any file that matches the target --pattern. *Note Last Resort::. -- -- Pattern rules may have more than one target. Unlike normal rules, --this does not act as many different rules with the same prerequisites --and commands. If a pattern rule has multiple targets, `make' knows that --the rule's commands are responsible for making all of the targets. The --commands are executed only once to make all the targets. When searching --for a pattern rule to match a target, the target patterns of a rule --other than the one that matches the target in need of a rule are --incidental: `make' worries only about giving commands and prerequisites --to the file presently in question. However, when this file's commands --are run, the other targets are marked as having been updated themselves. -- -- The order in which pattern rules appear in the makefile is important --since this is the order in which they are considered. Of equally --applicable rules, only the first one found is used. The rules you --write take precedence over those that are built in. Note however, that --a rule whose prerequisites actually exist or are mentioned always takes --priority over a rule with prerequisites that must be made by chaining --other implicit rules. -- -- --File: make.info, Node: Pattern Examples, Next: Automatic Variables, Prev: Pattern Intro, Up: Pattern Rules -- --10.5.2 Pattern Rule Examples ------------------------------ -- --Here are some examples of pattern rules actually predefined in `make'. --First, the rule that compiles `.c' files into `.o' files: -- -- %.o : %.c -- $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ -- --defines a rule that can make any file `X.o' from `X.c'. The command --uses the automatic variables `$@' and `$<' to substitute the names of --the target file and the source file in each case where the rule applies --(*note Automatic Variables::). -- -- Here is a second built-in rule: -- -- % :: RCS/%,v -- $(CO) $(COFLAGS) $< -- --defines a rule that can make any file `X' whatsoever from a --corresponding file `X,v' in the subdirectory `RCS'. Since the target --is `%', this rule will apply to any file whatever, provided the --appropriate prerequisite file exists. The double colon makes the rule --"terminal", which means that its prerequisite may not be an intermediate --file (*note Match-Anything Pattern Rules: Match-Anything Rules.). -- -- This pattern rule has two targets: -- -- %.tab.c %.tab.h: %.y -- bison -d $< -- --This tells `make' that the command `bison -d X.y' will make both --`X.tab.c' and `X.tab.h'. If the file `foo' depends on the files --`parse.tab.o' and `scan.o' and the file `scan.o' depends on the file --`parse.tab.h', when `parse.y' is changed, the command `bison -d parse.y' --will be executed only once, and the prerequisites of both `parse.tab.o' --and `scan.o' will be satisfied. (Presumably the file `parse.tab.o' --will be recompiled from `parse.tab.c' and the file `scan.o' from --`scan.c', while `foo' is linked from `parse.tab.o', `scan.o', and its --other prerequisites, and it will execute happily ever after.) -- -- --File: make.info, Node: Automatic Variables, Next: Pattern Match, Prev: Pattern Examples, Up: Pattern Rules -- --10.5.3 Automatic Variables ---------------------------- -- --Suppose you are writing a pattern rule to compile a `.c' file into a --`.o' file: how do you write the `cc' command so that it operates on the --right source file name? You cannot write the name in the command, --because the name is different each time the implicit rule is applied. -- -- What you do is use a special feature of `make', the "automatic --variables". These variables have values computed afresh for each rule --that is executed, based on the target and prerequisites of the rule. --In this example, you would use `$@' for the object file name and `$<' --for the source file name. -- -- It's very important that you recognize the limited scope in which --automatic variable values are available: they only have values within --the command script. In particular, you cannot use them anywhere within --the target list of a rule; they have no value there and will expand to --the empty string. Also, they cannot be accessed directly within the --prerequisite list of a rule. A common mistake is attempting to use --`$@' within the prerequisites list; this will not work. However, there --is a special feature of GNU `make', secondary expansion (*note --Secondary Expansion::), which will allow automatic variable values to --be used in prerequisite lists. -- -- Here is a table of automatic variables: -- --`$@' -- The file name of the target of the rule. If the target is an -- archive member, then `$@' is the name of the archive file. In a -- pattern rule that has multiple targets (*note Introduction to -- Pattern Rules: Pattern Intro.), `$@' is the name of whichever -- target caused the rule's commands to be run. -- --`$%' -- The target member name, when the target is an archive member. -- *Note Archives::. For example, if the target is `foo.a(bar.o)' -- then `$%' is `bar.o' and `$@' is `foo.a'. `$%' is empty when the -- target is not an archive member. -- --`$<' -- The name of the first prerequisite. If the target got its -- commands from an implicit rule, this will be the first -- prerequisite added by the implicit rule (*note Implicit Rules::). -- --`$?' -- The names of all the prerequisites that are newer than the target, -- with spaces between them. For prerequisites which are archive -- members, only the member named is used (*note Archives::). -- --`$^' -- The names of all the prerequisites, with spaces between them. For -- prerequisites which are archive members, only the member named is -- used (*note Archives::). A target has only one prerequisite on -- each other file it depends on, no matter how many times each file -- is listed as a prerequisite. So if you list a prerequisite more -- than once for a target, the value of `$^' contains just one copy -- of the name. This list does *not* contain any of the order-only -- prerequisites; for those see the `$|' variable, below. -- --`$+' -- This is like `$^', but prerequisites listed more than once are -- duplicated in the order they were listed in the makefile. This is -- primarily useful for use in linking commands where it is -- meaningful to repeat library file names in a particular order. -- --`$|' -- The names of all the order-only prerequisites, with spaces between -- them. -- --`$*' -- The stem with which an implicit rule matches (*note How Patterns -- Match: Pattern Match.). If the target is `dir/a.foo.b' and the -- target pattern is `a.%.b' then the stem is `dir/foo'. The stem is -- useful for constructing names of related files. -- -- In a static pattern rule, the stem is part of the file name that -- matched the `%' in the target pattern. -- -- In an explicit rule, there is no stem; so `$*' cannot be determined -- in that way. Instead, if the target name ends with a recognized -- suffix (*note Old-Fashioned Suffix Rules: Suffix Rules.), `$*' is -- set to the target name minus the suffix. For example, if the -- target name is `foo.c', then `$*' is set to `foo', since `.c' is a -- suffix. GNU `make' does this bizarre thing only for compatibility -- with other implementations of `make'. You should generally avoid -- using `$*' except in implicit rules or static pattern rules. -- -- If the target name in an explicit rule does not end with a -- recognized suffix, `$*' is set to the empty string for that rule. -- -- `$?' is useful even in explicit rules when you wish to operate on --only the prerequisites that have changed. For example, suppose that an --archive named `lib' is supposed to contain copies of several object --files. This rule copies just the changed object files into the archive: -- -- lib: foo.o bar.o lose.o win.o -- ar r lib $? -- -- Of the variables listed above, four have values that are single file --names, and three have values that are lists of file names. These seven --have variants that get just the file's directory name or just the file --name within the directory. The variant variables' names are formed by --appending `D' or `F', respectively. These variants are semi-obsolete --in GNU `make' since the functions `dir' and `notdir' can be used to get --a similar effect (*note Functions for File Names: File Name --Functions.). Note, however, that the `D' variants all omit the --trailing slash which always appears in the output of the `dir' --function. Here is a table of the variants: -- --`$(@D)' -- The directory part of the file name of the target, with the -- trailing slash removed. If the value of `$@' is `dir/foo.o' then -- `$(@D)' is `dir'. This value is `.' if `$@' does not contain a -- slash. -- --`$(@F)' -- The file-within-directory part of the file name of the target. If -- the value of `$@' is `dir/foo.o' then `$(@F)' is `foo.o'. `$(@F)' -- is equivalent to `$(notdir $@)'. -- --`$(*D)' --`$(*F)' -- The directory part and the file-within-directory part of the stem; -- `dir' and `foo' in this example. -- --`$(%D)' --`$(%F)' -- The directory part and the file-within-directory part of the target -- archive member name. This makes sense only for archive member -- targets of the form `ARCHIVE(MEMBER)' and is useful only when -- MEMBER may contain a directory name. (*Note Archive Members as -- Targets: Archive Members.) -- --`$( foo.1 -- --will fail when the build directory is not the source directory, because --`foo.man' and `sedscript' are in the source directory. -- -- When using GNU `make', relying on `VPATH' to find the source file --will work in the case where there is a single dependency file, since --the `make' automatic variable `$<' will represent the source file --wherever it is. (Many versions of `make' set `$<' only in implicit --rules.) A Makefile target like -- -- foo.o : bar.c -- $(CC) -I. -I$(srcdir) $(CFLAGS) -c bar.c -o foo.o -- --should instead be written as -- -- foo.o : bar.c -- $(CC) -I. -I$(srcdir) $(CFLAGS) -c $< -o $@ -- --in order to allow `VPATH' to work correctly. When the target has --multiple dependencies, using an explicit `$(srcdir)' is the easiest way --to make the rule work well. For example, the target above for `foo.1' --is best written as: -- -- foo.1 : foo.man sedscript -- sed -e $(srcdir)/sedscript $(srcdir)/foo.man > $@ -- -- GNU distributions usually contain some files which are not source --files--for example, Info files, and the output from Autoconf, Automake, --Bison or Flex. Since these files normally appear in the source --directory, they should always appear in the source directory, not in the --build directory. So Makefile rules to update them should put the --updated files in the source directory. -- -- However, if a file does not appear in the distribution, then the --Makefile should not put it in the source directory, because building a --program in ordinary circumstances should not modify the source directory --in any way. -- -- Try to make the build and installation targets, at least (and all --their subtargets) work correctly with a parallel `make'. -- -- --File: make.info, Node: Utilities in Makefiles, Next: Command Variables, Prev: Makefile Basics, Up: Makefile Conventions -- --14.2 Utilities in Makefiles --=========================== -- --Write the Makefile commands (and any shell scripts, such as --`configure') to run in `sh', not in `csh'. Don't use any special --features of `ksh' or `bash'. -- -- The `configure' script and the Makefile rules for building and --installation should not use any utilities directly except these: -- -- cat cmp cp diff echo egrep expr false grep install-info -- ln ls mkdir mv pwd rm rmdir sed sleep sort tar test touch true -- -- The compression program `gzip' can be used in the `dist' rule. -- -- Stick to the generally supported options for these programs. For --example, don't use `mkdir -p', convenient as it may be, because most --systems don't support it. -- -- It is a good idea to avoid creating symbolic links in makefiles, --since a few systems don't support them. -- -- The Makefile rules for building and installation can also use --compilers and related programs, but should do so via `make' variables --so that the user can substitute alternatives. Here are some of the --programs we mean: -- -- ar bison cc flex install ld ldconfig lex -- make makeinfo ranlib texi2dvi yacc -- -- Use the following `make' variables to run those programs: -- -- $(AR) $(BISON) $(CC) $(FLEX) $(INSTALL) $(LD) $(LDCONFIG) $(LEX) -- $(MAKE) $(MAKEINFO) $(RANLIB) $(TEXI2DVI) $(YACC) -- -- When you use `ranlib' or `ldconfig', you should make sure nothing --bad happens if the system does not have the program in question. --Arrange to ignore an error from that command, and print a message before --the command to tell the user that failure of this command does not mean --a problem. (The Autoconf `AC_PROG_RANLIB' macro can help with this.) -- -- If you use symbolic links, you should implement a fallback for --systems that don't have symbolic links. -- -- Additional utilities that can be used via Make variables are: -- -- chgrp chmod chown mknod -- -- It is ok to use other utilities in Makefile portions (or scripts) --intended only for particular systems where you know those utilities --exist. -- -- --File: make.info, Node: Command Variables, Next: Directory Variables, Prev: Utilities in Makefiles, Up: Makefile Conventions -- --14.3 Variables for Specifying Commands --====================================== -- --Makefiles should provide variables for overriding certain commands, --options, and so on. -- -- In particular, you should run most utility programs via variables. --Thus, if you use Bison, have a variable named `BISON' whose default --value is set with `BISON = bison', and refer to it with `$(BISON)' --whenever you need to use Bison. -- -- File management utilities such as `ln', `rm', `mv', and so on, need --not be referred to through variables in this way, since users don't --need to replace them with other programs. -- -- Each program-name variable should come with an options variable that --is used to supply options to the program. Append `FLAGS' to the --program-name variable name to get the options variable name--for --example, `BISONFLAGS'. (The names `CFLAGS' for the C compiler, --`YFLAGS' for yacc, and `LFLAGS' for lex, are exceptions to this rule, --but we keep them because they are standard.) Use `CPPFLAGS' in any --compilation command that runs the preprocessor, and use `LDFLAGS' in --any compilation command that does linking as well as in any direct use --of `ld'. -- -- If there are C compiler options that _must_ be used for proper --compilation of certain files, do not include them in `CFLAGS'. Users --expect to be able to specify `CFLAGS' freely themselves. Instead, --arrange to pass the necessary options to the C compiler independently --of `CFLAGS', by writing them explicitly in the compilation commands or --by defining an implicit rule, like this: -- -- CFLAGS = -g -- ALL_CFLAGS = -I. $(CFLAGS) -- .c.o: -- $(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $< -- -- Do include the `-g' option in `CFLAGS', because that is not --_required_ for proper compilation. You can consider it a default that --is only recommended. If the package is set up so that it is compiled --with GCC by default, then you might as well include `-O' in the default --value of `CFLAGS' as well. -- -- Put `CFLAGS' last in the compilation command, after other variables --containing compiler options, so the user can use `CFLAGS' to override --the others. -- -- `CFLAGS' should be used in every invocation of the C compiler, both --those which do compilation and those which do linking. -- -- Every Makefile should define the variable `INSTALL', which is the --basic command for installing a file into the system. -- -- Every Makefile should also define the variables `INSTALL_PROGRAM' --and `INSTALL_DATA'. (The default for `INSTALL_PROGRAM' should be --`$(INSTALL)'; the default for `INSTALL_DATA' should be `${INSTALL} -m --644'.) Then it should use those variables as the commands for actual --installation, for executables and nonexecutables respectively. Use --these variables as follows: -- -- $(INSTALL_PROGRAM) foo $(bindir)/foo -- $(INSTALL_DATA) libfoo.a $(libdir)/libfoo.a -- -- Optionally, you may prepend the value of `DESTDIR' to the target --filename. Doing this allows the installer to create a snapshot of the --installation to be copied onto the real target filesystem later. Do not --set the value of `DESTDIR' in your Makefile, and do not include it in --any installed files. With support for `DESTDIR', the above examples --become: -- -- $(INSTALL_PROGRAM) foo $(DESTDIR)$(bindir)/foo -- $(INSTALL_DATA) libfoo.a $(DESTDIR)$(libdir)/libfoo.a -- --Always use a file name, not a directory name, as the second argument of --the installation commands. Use a separate command for each file to be --installed. -- -- --File: make.info, Node: Directory Variables, Next: Standard Targets, Prev: Command Variables, Up: Makefile Conventions -- --14.4 Variables for Installation Directories --=========================================== -- --Installation directories should always be named by variables, so it is --easy to install in a nonstandard place. The standard names for these --variables and the values they should have in GNU packages are described --below. They are based on a standard filesystem layout; variants of it --are used in GNU/Linux and other modern operating systems. -- -- Installers are expected to override these values when calling `make' --(e.g., `make prefix=/usr install' or `configure' (e.g., `configure ----prefix=/usr'). GNU packages should not try to guess which value --should be appropriate for these variables on the system they are being --installed onto: use the default settings specified here so that all GNU --packages behave identically, allowing the installer to achieve any --desired layout. -- -- These two variables set the root for the installation. All the other --installation directories should be subdirectories of one of these two, --and nothing should be directly installed into these two directories. -- --`prefix' -- A prefix used in constructing the default values of the variables -- listed below. The default value of `prefix' should be -- `/usr/local'. When building the complete GNU system, the prefix -- will be empty and `/usr' will be a symbolic link to `/'. (If you -- are using Autoconf, write it as `@prefix@'.) -- -- Running `make install' with a different value of `prefix' from the -- one used to build the program should _not_ recompile the program. -- --`exec_prefix' -- A prefix used in constructing the default values of some of the -- variables listed below. The default value of `exec_prefix' should -- be `$(prefix)'. (If you are using Autoconf, write it as -- `@exec_prefix@'.) -- -- Generally, `$(exec_prefix)' is used for directories that contain -- machine-specific files (such as executables and subroutine -- libraries), while `$(prefix)' is used directly for other -- directories. -- -- Running `make install' with a different value of `exec_prefix' -- from the one used to build the program should _not_ recompile the -- program. -- -- Executable programs are installed in one of the following --directories. -- --`bindir' -- The directory for installing executable programs that users can -- run. This should normally be `/usr/local/bin', but write it as -- `$(exec_prefix)/bin'. (If you are using Autoconf, write it as -- `@bindir@'.) -- --`sbindir' -- The directory for installing executable programs that can be run -- from the shell, but are only generally useful to system -- administrators. This should normally be `/usr/local/sbin', but -- write it as `$(exec_prefix)/sbin'. (If you are using Autoconf, -- write it as `@sbindir@'.) -- --`libexecdir' -- The directory for installing executable programs to be run by other -- programs rather than by users. This directory should normally be -- `/usr/local/libexec', but write it as `$(exec_prefix)/libexec'. -- (If you are using Autoconf, write it as `@libexecdir@'.) -- -- The definition of `libexecdir' is the same for all packages, so -- you should install your data in a subdirectory thereof. Most -- packages install their data under `$(libexecdir)/PACKAGE-NAME/', -- possibly within additional subdirectories thereof, such as -- `$(libexecdir)/PACKAGE-NAME/MACHINE/VERSION'. -- -- Data files used by the program during its execution are divided into --categories in two ways. -- -- * Some files are normally modified by programs; others are never -- normally modified (though users may edit some of these). -- -- * Some files are architecture-independent and can be shared by all -- machines at a site; some are architecture-dependent and can be -- shared only by machines of the same kind and operating system; -- others may never be shared between two machines. -- -- This makes for six different possibilities. However, we want to --discourage the use of architecture-dependent files, aside from object --files and libraries. It is much cleaner to make other data files --architecture-independent, and it is generally not hard. -- -- Here are the variables Makefiles should use to specify directories --to put these various kinds of files in: -- --`datarootdir' -- The root of the directory tree for read-only -- architecture-independent data files. This should normally be -- `/usr/local/share', but write it as `$(prefix)/share'. (If you -- are using Autoconf, write it as `@datarootdir@'.) `datadir''s -- default value is based on this variable; so are `infodir', -- `mandir', and others. -- --`datadir' -- The directory for installing idiosyncratic read-only -- architecture-independent data files for this program. This is -- usually the same place as `datarootdir', but we use the two -- separate variables so that you can move these program-specific -- files without altering the location for Info files, man pages, etc. -- -- This should normally be `/usr/local/share', but write it as -- `$(datarootdir)'. (If you are using Autoconf, write it as -- `@datadir@'.) -- -- The definition of `datadir' is the same for all packages, so you -- should install your data in a subdirectory thereof. Most packages -- install their data under `$(datadir)/PACKAGE-NAME/'. -- --`sysconfdir' -- The directory for installing read-only data files that pertain to a -- single machine-that is to say, files for configuring a host. -- Mailer and network configuration files, `/etc/passwd', and so -- forth belong here. All the files in this directory should be -- ordinary ASCII text files. This directory should normally be -- `/usr/local/etc', but write it as `$(prefix)/etc'. (If you are -- using Autoconf, write it as `@sysconfdir@'.) -- -- Do not install executables here in this directory (they probably -- belong in `$(libexecdir)' or `$(sbindir)'). Also do not install -- files that are modified in the normal course of their use (programs -- whose purpose is to change the configuration of the system -- excluded). Those probably belong in `$(localstatedir)'. -- --`sharedstatedir' -- The directory for installing architecture-independent data files -- which the programs modify while they run. This should normally be -- `/usr/local/com', but write it as `$(prefix)/com'. (If you are -- using Autoconf, write it as `@sharedstatedir@'.) -- --`localstatedir' -- The directory for installing data files which the programs modify -- while they run, and that pertain to one specific machine. Users -- should never need to modify files in this directory to configure -- the package's operation; put such configuration information in -- separate files that go in `$(datadir)' or `$(sysconfdir)'. -- `$(localstatedir)' should normally be `/usr/local/var', but write -- it as `$(prefix)/var'. (If you are using Autoconf, write it as -- `@localstatedir@'.) -- -- These variables specify the directory for installing certain specific --types of files, if your program has them. Every GNU package should --have Info files, so every program needs `infodir', but not all need --`libdir' or `lispdir'. -- --`includedir' -- The directory for installing header files to be included by user -- programs with the C `#include' preprocessor directive. This -- should normally be `/usr/local/include', but write it as -- `$(prefix)/include'. (If you are using Autoconf, write it as -- `@includedir@'.) -- -- Most compilers other than GCC do not look for header files in -- directory `/usr/local/include'. So installing the header files -- this way is only useful with GCC. Sometimes this is not a problem -- because some libraries are only really intended to work with GCC. -- But some libraries are intended to work with other compilers. -- They should install their header files in two places, one -- specified by `includedir' and one specified by `oldincludedir'. -- --`oldincludedir' -- The directory for installing `#include' header files for use with -- compilers other than GCC. This should normally be `/usr/include'. -- (If you are using Autoconf, you can write it as `@oldincludedir@'.) -- -- The Makefile commands should check whether the value of -- `oldincludedir' is empty. If it is, they should not try to use -- it; they should cancel the second installation of the header files. -- -- A package should not replace an existing header in this directory -- unless the header came from the same package. Thus, if your Foo -- package provides a header file `foo.h', then it should install the -- header file in the `oldincludedir' directory if either (1) there -- is no `foo.h' there or (2) the `foo.h' that exists came from the -- Foo package. -- -- To tell whether `foo.h' came from the Foo package, put a magic -- string in the file--part of a comment--and `grep' for that string. -- --`docdir' -- The directory for installing documentation files (other than Info) -- for this package. By default, it should be -- `/usr/local/share/doc/YOURPKG', but it should be written as -- `$(datarootdir)/doc/YOURPKG'. (If you are using Autoconf, write -- it as `@docdir@'.) The YOURPKG subdirectory, which may include a -- version number, prevents collisions among files with common names, -- such as `README'. -- --`infodir' -- The directory for installing the Info files for this package. By -- default, it should be `/usr/local/share/info', but it should be -- written as `$(datarootdir)/info'. (If you are using Autoconf, -- write it as `@infodir@'.) `infodir' is separate from `docdir' for -- compatibility with existing practice. -- --`htmldir' --`dvidir' --`pdfdir' --`psdir' -- Directories for installing documentation files in the particular -- format. (It is not required to support documentation in all these -- formats.) They should all be set to `$(docdir)' by default. (If -- you are using Autoconf, write them as `@htmldir@', `@dvidir@', -- etc.) Packages which supply several translations of their -- documentation should install them in `$(htmldir)/'LL, -- `$(pdfdir)/'LL, etc. where LL is a locale abbreviation such as -- `en' or `pt_BR'. -- --`libdir' -- The directory for object files and libraries of object code. Do -- not install executables here, they probably ought to go in -- `$(libexecdir)' instead. The value of `libdir' should normally be -- `/usr/local/lib', but write it as `$(exec_prefix)/lib'. (If you -- are using Autoconf, write it as `@libdir@'.) -- --`lispdir' -- The directory for installing any Emacs Lisp files in this package. -- By default, it should be `/usr/local/share/emacs/site-lisp', but -- it should be written as `$(datarootdir)/emacs/site-lisp'. -- -- If you are using Autoconf, write the default as `@lispdir@'. In -- order to make `@lispdir@' work, you need the following lines in -- your `configure.in' file: -- -- lispdir='${datarootdir}/emacs/site-lisp' -- AC_SUBST(lispdir) -- --`localedir' -- The directory for installing locale-specific message catalogs for -- this package. By default, it should be `/usr/local/share/locale', -- but it should be written as `$(datarootdir)/locale'. (If you are -- using Autoconf, write it as `@localedir@'.) This directory -- usually has a subdirectory per locale. -- -- Unix-style man pages are installed in one of the following: -- --`mandir' -- The top-level directory for installing the man pages (if any) for -- this package. It will normally be `/usr/local/share/man', but you -- should write it as `$(datarootdir)/man'. (If you are using -- Autoconf, write it as `@mandir@'.) -- --`man1dir' -- The directory for installing section 1 man pages. Write it as -- `$(mandir)/man1'. -- --`man2dir' -- The directory for installing section 2 man pages. Write it as -- `$(mandir)/man2' -- --`...' -- *Don't make the primary documentation for any GNU software be a -- man page. Write a manual in Texinfo instead. Man pages are just -- for the sake of people running GNU software on Unix, which is a -- secondary application only.* -- --`manext' -- The file name extension for the installed man page. This should -- contain a period followed by the appropriate digit; it should -- normally be `.1'. -- --`man1ext' -- The file name extension for installed section 1 man pages. -- --`man2ext' -- The file name extension for installed section 2 man pages. -- --`...' -- Use these names instead of `manext' if the package needs to -- install man pages in more than one section of the manual. -- -- And finally, you should set the following variable: -- --`srcdir' -- The directory for the sources being compiled. The value of this -- variable is normally inserted by the `configure' shell script. -- (If you are using Autconf, use `srcdir = @srcdir@'.) -- -- For example: -- -- # Common prefix for installation directories. -- # NOTE: This directory must exist when you start the install. -- prefix = /usr/local -- datarootdir = $(prefix)/share -- datadir = $(datarootdir) -- exec_prefix = $(prefix) -- # Where to put the executable for the command `gcc'. -- bindir = $(exec_prefix)/bin -- # Where to put the directories used by the compiler. -- libexecdir = $(exec_prefix)/libexec -- # Where to put the Info files. -- infodir = $(datarootdir)/info -- -- If your program installs a large number of files into one of the --standard user-specified directories, it might be useful to group them --into a subdirectory particular to that program. If you do this, you --should write the `install' rule to create these subdirectories. -- -- Do not expect the user to include the subdirectory name in the value --of any of the variables listed above. The idea of having a uniform set --of variable names for installation directories is to enable the user to --specify the exact same values for several different GNU packages. In --order for this to be useful, all the packages must be designed so that --they will work sensibly when the user does so. -- -- --File: make.info, Node: Standard Targets, Next: Install Command Categories, Prev: Directory Variables, Up: Makefile Conventions -- --14.5 Standard Targets for Users --=============================== -- --All GNU programs should have the following targets in their Makefiles: -- --`all' -- Compile the entire program. This should be the default target. -- This target need not rebuild any documentation files; Info files -- should normally be included in the distribution, and DVI files -- should be made only when explicitly asked for. -- -- By default, the Make rules should compile and link with `-g', so -- that executable programs have debugging symbols. Users who don't -- mind being helpless can strip the executables later if they wish. -- --`install' -- Compile the program and copy the executables, libraries, and so on -- to the file names where they should reside for actual use. If -- there is a simple test to verify that a program is properly -- installed, this target should run that test. -- -- Do not strip executables when installing them. Devil-may-care -- users can use the `install-strip' target to do that. -- -- If possible, write the `install' target rule so that it does not -- modify anything in the directory where the program was built, -- provided `make all' has just been done. This is convenient for -- building the program under one user name and installing it under -- another. -- -- The commands should create all the directories in which files are -- to be installed, if they don't already exist. This includes the -- directories specified as the values of the variables `prefix' and -- `exec_prefix', as well as all subdirectories that are needed. One -- way to do this is by means of an `installdirs' target as described -- below. -- -- Use `-' before any command for installing a man page, so that -- `make' will ignore any errors. This is in case there are systems -- that don't have the Unix man page documentation system installed. -- -- The way to install Info files is to copy them into `$(infodir)' -- with `$(INSTALL_DATA)' (*note Command Variables::), and then run -- the `install-info' program if it is present. `install-info' is a -- program that edits the Info `dir' file to add or update the menu -- entry for the given Info file; it is part of the Texinfo package. -- Here is a sample rule to install an Info file: -- -- $(DESTDIR)$(infodir)/foo.info: foo.info -- $(POST_INSTALL) -- # There may be a newer info file in . than in srcdir. -- -if test -f foo.info; then d=.; \ -- else d=$(srcdir); fi; \ -- $(INSTALL_DATA) $$d/foo.info $(DESTDIR)$@; \ -- # Run install-info only if it exists. -- # Use `if' instead of just prepending `-' to the -- # line so we notice real errors from install-info. -- # We use `$(SHELL) -c' because some shells do not -- # fail gracefully when there is an unknown command. -- if $(SHELL) -c 'install-info --version' \ -- >/dev/null 2>&1; then \ -- install-info --dir-file=$(DESTDIR)$(infodir)/dir \ -- $(DESTDIR)$(infodir)/foo.info; \ -- else true; fi -- -- When writing the `install' target, you must classify all the -- commands into three categories: normal ones, "pre-installation" -- commands and "post-installation" commands. *Note Install Command -- Categories::. -- --`install-html' --`install-dvi' --`install-pdf' --`install-ps' -- These targets install documentation in formats other than Info; -- they're intended to be called explicitly by the person installing -- the package, if that format is desired. GNU prefers Info files, -- so these must be installed by the `install' target. -- -- When you have many documentation files to install, we recommend -- that you avoid collisions and clutter by arranging for these -- targets to install in subdirectories of the appropriate -- installation directory, such as `htmldir'. As one example, if -- your package has multiple manuals, and you wish to install HTML -- documentation with many files (such as the "split" mode output by -- `makeinfo --html'), you'll certainly want to use subdirectories, -- or two nodes with the same name in different manuals will -- overwrite each other. -- --`uninstall' -- Delete all the installed files--the copies that the `install' and -- `install-*' targets create. -- -- This rule should not modify the directories where compilation is -- done, only the directories where files are installed. -- -- The uninstallation commands are divided into three categories, -- just like the installation commands. *Note Install Command -- Categories::. -- --`install-strip' -- Like `install', but strip the executable files while installing -- them. In simple cases, this target can use the `install' target in -- a simple way: -- -- install-strip: -- $(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' \ -- install -- -- But if the package installs scripts as well as real executables, -- the `install-strip' target can't just refer to the `install' -- target; it has to strip the executables but not the scripts. -- -- `install-strip' should not strip the executables in the build -- directory which are being copied for installation. It should only -- strip the copies that are installed. -- -- Normally we do not recommend stripping an executable unless you -- are sure the program has no bugs. However, it can be reasonable -- to install a stripped executable for actual execution while saving -- the unstripped executable elsewhere in case there is a bug. -- --`clean' -- Delete all files in the current directory that are normally -- created by building the program. Also delete files in other -- directories if they are created by this makefile. However, don't -- delete the files that record the configuration. Also preserve -- files that could be made by building, but normally aren't because -- the distribution comes with them. There is no need to delete -- parent directories that were created with `mkdir -p', since they -- could have existed anyway. -- -- Delete `.dvi' files here if they are not part of the distribution. -- --`distclean' -- Delete all files in the current directory (or created by this -- makefile) that are created by configuring or building the program. -- If you have unpacked the source and built the program without -- creating any other files, `make distclean' should leave only the -- files that were in the distribution. However, there is no need to -- delete parent directories that were created with `mkdir -p', since -- they could have existed anyway. -- --`mostlyclean' -- Like `clean', but may refrain from deleting a few files that people -- normally don't want to recompile. For example, the `mostlyclean' -- target for GCC does not delete `libgcc.a', because recompiling it -- is rarely necessary and takes a lot of time. -- --`maintainer-clean' -- Delete almost everything that can be reconstructed with this -- Makefile. This typically includes everything deleted by -- `distclean', plus more: C source files produced by Bison, tags -- tables, Info files, and so on. -- -- The reason we say "almost everything" is that running the command -- `make maintainer-clean' should not delete `configure' even if -- `configure' can be remade using a rule in the Makefile. More -- generally, `make maintainer-clean' should not delete anything that -- needs to exist in order to run `configure' and then begin to build -- the program. Also, there is no need to delete parent directories -- that were created with `mkdir -p', since they could have existed -- anyway. These are the only exceptions; `maintainer-clean' should -- delete everything else that can be rebuilt. -- -- The `maintainer-clean' target is intended to be used by a -- maintainer of the package, not by ordinary users. You may need -- special tools to reconstruct some of the files that `make -- maintainer-clean' deletes. Since these files are normally -- included in the distribution, we don't take care to make them easy -- to reconstruct. If you find you need to unpack the full -- distribution again, don't blame us. -- -- To help make users aware of this, the commands for the special -- `maintainer-clean' target should start with these two: -- -- @echo 'This command is intended for maintainers to use; it' -- @echo 'deletes files that may need special tools to rebuild.' -- --`TAGS' -- Update a tags table for this program. -- --`info' -- Generate any Info files needed. The best way to write the rules -- is as follows: -- -- info: foo.info -- -- foo.info: foo.texi chap1.texi chap2.texi -- $(MAKEINFO) $(srcdir)/foo.texi -- -- You must define the variable `MAKEINFO' in the Makefile. It should -- run the `makeinfo' program, which is part of the Texinfo -- distribution. -- -- Normally a GNU distribution comes with Info files, and that means -- the Info files are present in the source directory. Therefore, -- the Make rule for an info file should update it in the source -- directory. When users build the package, ordinarily Make will not -- update the Info files because they will already be up to date. -- --`dvi' --`html' --`pdf' --`ps' -- Generate documentation files in the given format, if possible. -- Here's an example rule for generating DVI files from Texinfo: -- -- dvi: foo.dvi -- -- foo.dvi: foo.texi chap1.texi chap2.texi -- $(TEXI2DVI) $(srcdir)/foo.texi -- -- You must define the variable `TEXI2DVI' in the Makefile. It should -- run the program `texi2dvi', which is part of the Texinfo -- distribution.(1) Alternatively, write just the dependencies, and -- allow GNU `make' to provide the command. -- -- Here's another example, this one for generating HTML from Texinfo: -- -- html: foo.html -- -- foo.html: foo.texi chap1.texi chap2.texi -- $(TEXI2HTML) $(srcdir)/foo.texi -- -- Again, you would define the variable `TEXI2HTML' in the Makefile; -- for example, it might run `makeinfo --no-split --html' (`makeinfo' -- is part of the Texinfo distribution). -- --`dist' -- Create a distribution tar file for this program. The tar file -- should be set up so that the file names in the tar file start with -- a subdirectory name which is the name of the package it is a -- distribution for. This name can include the version number. -- -- For example, the distribution tar file of GCC version 1.40 unpacks -- into a subdirectory named `gcc-1.40'. -- -- The easiest way to do this is to create a subdirectory -- appropriately named, use `ln' or `cp' to install the proper files -- in it, and then `tar' that subdirectory. -- -- Compress the tar file with `gzip'. For example, the actual -- distribution file for GCC version 1.40 is called `gcc-1.40.tar.gz'. -- -- The `dist' target should explicitly depend on all non-source files -- that are in the distribution, to make sure they are up to date in -- the distribution. *Note Making Releases: (standards)Releases. -- --`check' -- Perform self-tests (if any). The user must build the program -- before running the tests, but need not install the program; you -- should write the self-tests so that they work when the program is -- built but not installed. -- -- The following targets are suggested as conventional names, for --programs in which they are useful. -- --`installcheck' -- Perform installation tests (if any). The user must build and -- install the program before running the tests. You should not -- assume that `$(bindir)' is in the search path. -- --`installdirs' -- It's useful to add a target named `installdirs' to create the -- directories where files are installed, and their parent -- directories. There is a script called `mkinstalldirs' which is -- convenient for this; you can find it in the Texinfo package. You -- can use a rule like this: -- -- # Make sure all installation directories (e.g. $(bindir)) -- # actually exist by making them if necessary. -- installdirs: mkinstalldirs -- $(srcdir)/mkinstalldirs $(bindir) $(datadir) \ -- $(libdir) $(infodir) \ -- $(mandir) -- -- or, if you wish to support `DESTDIR', -- -- # Make sure all installation directories (e.g. $(bindir)) -- # actually exist by making them if necessary. -- installdirs: mkinstalldirs -- $(srcdir)/mkinstalldirs \ -- $(DESTDIR)$(bindir) $(DESTDIR)$(datadir) \ -- $(DESTDIR)$(libdir) $(DESTDIR)$(infodir) \ -- $(DESTDIR)$(mandir) -- -- This rule should not modify the directories where compilation is -- done. It should do nothing but create installation directories. -- -- ---------- Footnotes ---------- -- -- (1) `texi2dvi' uses TeX to do the real work of formatting. TeX is --not distributed with Texinfo. -- -- --File: make.info, Node: Install Command Categories, Prev: Standard Targets, Up: Makefile Conventions -- --14.6 Install Command Categories --=============================== -- --When writing the `install' target, you must classify all the commands --into three categories: normal ones, "pre-installation" commands and --"post-installation" commands. -- -- Normal commands move files into their proper places, and set their --modes. They may not alter any files except the ones that come entirely --from the package they belong to. -- -- Pre-installation and post-installation commands may alter other --files; in particular, they can edit global configuration files or data --bases. -- -- Pre-installation commands are typically executed before the normal --commands, and post-installation commands are typically run after the --normal commands. -- -- The most common use for a post-installation command is to run --`install-info'. This cannot be done with a normal command, since it --alters a file (the Info directory) which does not come entirely and --solely from the package being installed. It is a post-installation --command because it needs to be done after the normal command which --installs the package's Info files. -- -- Most programs don't need any pre-installation commands, but we have --the feature just in case it is needed. -- -- To classify the commands in the `install' rule into these three --categories, insert "category lines" among them. A category line --specifies the category for the commands that follow. -- -- A category line consists of a tab and a reference to a special Make --variable, plus an optional comment at the end. There are three --variables you can use, one for each category; the variable name --specifies the category. Category lines are no-ops in ordinary execution --because these three Make variables are normally undefined (and you --_should not_ define them in the makefile). -- -- Here are the three possible category lines, each with a comment that --explains what it means: -- -- $(PRE_INSTALL) # Pre-install commands follow. -- $(POST_INSTALL) # Post-install commands follow. -- $(NORMAL_INSTALL) # Normal commands follow. -- -- If you don't use a category line at the beginning of the `install' --rule, all the commands are classified as normal until the first category --line. If you don't use any category lines, all the commands are --classified as normal. -- -- These are the category lines for `uninstall': -- -- $(PRE_UNINSTALL) # Pre-uninstall commands follow. -- $(POST_UNINSTALL) # Post-uninstall commands follow. -- $(NORMAL_UNINSTALL) # Normal commands follow. -- -- Typically, a pre-uninstall command would be used for deleting entries --from the Info directory. -- -- If the `install' or `uninstall' target has any dependencies which --act as subroutines of installation, then you should start _each_ --dependency's commands with a category line, and start the main target's --commands with a category line also. This way, you can ensure that each --command is placed in the right category regardless of which of the --dependencies actually run. -- -- Pre-installation and post-installation commands should not run any --programs except for these: -- -- [ basename bash cat chgrp chmod chown cmp cp dd diff echo -- egrep expand expr false fgrep find getopt grep gunzip gzip -- hostname install install-info kill ldconfig ln ls md5sum -- mkdir mkfifo mknod mv printenv pwd rm rmdir sed sort tee -- test touch true uname xargs yes -- -- The reason for distinguishing the commands in this way is for the --sake of making binary packages. Typically a binary package contains --all the executables and other files that need to be installed, and has --its own method of installing them--so it does not need to run the normal --installation commands. But installing the binary package does need to --execute the pre-installation and post-installation commands. -- -- Programs to build binary packages work by extracting the --pre-installation and post-installation commands. Here is one way of --extracting the pre-installation commands (the `-s' option to `make' is --needed to silence messages about entering subdirectories): -- -- make -s -n install -o all \ -- PRE_INSTALL=pre-install \ -- POST_INSTALL=post-install \ -- NORMAL_INSTALL=normal-install \ -- | gawk -f pre-install.awk -- --where the file `pre-install.awk' could contain this: -- -- $0 ~ /^(normal-install|post-install)[ \t]*$/ {on = 0} -- on {print $0} -- $0 ~ /^pre-install[ \t]*$/ {on = 1} -- -- --File: make.info, Node: Quick Reference, Next: Error Messages, Prev: Makefile Conventions, Up: Top -- --Appendix A Quick Reference --************************** -- --This appendix summarizes the directives, text manipulation functions, --and special variables which GNU `make' understands. *Note Special --Targets::, *Note Catalogue of Implicit Rules: Catalogue of Rules, and --*Note Summary of Options: Options Summary, for other summaries. -- -- Here is a summary of the directives GNU `make' recognizes: -- --`define VARIABLE' --`endef' -- Define a multi-line, recursively-expanded variable. -- *Note Sequences::. -- --`ifdef VARIABLE' --`ifndef VARIABLE' --`ifeq (A,B)' --`ifeq "A" "B"' --`ifeq 'A' 'B'' --`ifneq (A,B)' --`ifneq "A" "B"' --`ifneq 'A' 'B'' --`else' --`endif' -- Conditionally evaluate part of the makefile. -- *Note Conditionals::. -- --`include FILE' --`-include FILE' --`sinclude FILE' -- Include another makefile. -- *Note Including Other Makefiles: Include. -- --`override VARIABLE = VALUE' --`override VARIABLE := VALUE' --`override VARIABLE += VALUE' --`override VARIABLE ?= VALUE' --`override define VARIABLE' --`endef' -- Define a variable, overriding any previous definition, even one -- from the command line. -- *Note The `override' Directive: Override Directive. -- --`export' -- Tell `make' to export all variables to child processes by default. -- *Note Communicating Variables to a Sub-`make': Variables/Recursion. -- --`export VARIABLE' --`export VARIABLE = VALUE' --`export VARIABLE := VALUE' --`export VARIABLE += VALUE' --`export VARIABLE ?= VALUE' --`unexport VARIABLE' -- Tell `make' whether or not to export a particular variable to child -- processes. -- *Note Communicating Variables to a Sub-`make': Variables/Recursion. -- --`vpath PATTERN PATH' -- Specify a search path for files matching a `%' pattern. -- *Note The `vpath' Directive: Selective Search. -- --`vpath PATTERN' -- Remove all search paths previously specified for PATTERN. -- --`vpath' -- Remove all search paths previously specified in any `vpath' -- directive. -- -- Here is a summary of the built-in functions (*note Functions::): -- --`$(subst FROM,TO,TEXT)' -- Replace FROM with TO in TEXT. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(patsubst PATTERN,REPLACEMENT,TEXT)' -- Replace words matching PATTERN with REPLACEMENT in TEXT. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(strip STRING)' -- Remove excess whitespace characters from STRING. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(findstring FIND,TEXT)' -- Locate FIND in TEXT. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(filter PATTERN...,TEXT)' -- Select words in TEXT that match one of the PATTERN words. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(filter-out PATTERN...,TEXT)' -- Select words in TEXT that _do not_ match any of the PATTERN words. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(sort LIST)' -- Sort the words in LIST lexicographically, removing duplicates. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(word N,TEXT)' -- Extract the Nth word (one-origin) of TEXT. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(words TEXT)' -- Count the number of words in TEXT. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(wordlist S,E,TEXT)' -- Returns the list of words in TEXT from S to E. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(firstword NAMES...)' -- Extract the first word of NAMES. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(lastword NAMES...)' -- Extract the last word of NAMES. -- *Note Functions for String Substitution and Analysis: Text -- Functions. -- --`$(dir NAMES...)' -- Extract the directory part of each file name. -- *Note Functions for File Names: File Name Functions. -- --`$(notdir NAMES...)' -- Extract the non-directory part of each file name. -- *Note Functions for File Names: File Name Functions. -- --`$(suffix NAMES...)' -- Extract the suffix (the last `.' and following characters) of each -- file name. -- *Note Functions for File Names: File Name Functions. -- --`$(basename NAMES...)' -- Extract the base name (name without suffix) of each file name. -- *Note Functions for File Names: File Name Functions. -- --`$(addsuffix SUFFIX,NAMES...)' -- Append SUFFIX to each word in NAMES. -- *Note Functions for File Names: File Name Functions. -- --`$(addprefix PREFIX,NAMES...)' -- Prepend PREFIX to each word in NAMES. -- *Note Functions for File Names: File Name Functions. -- --`$(join LIST1,LIST2)' -- Join two parallel lists of words. -- *Note Functions for File Names: File Name Functions. -- --`$(wildcard PATTERN...)' -- Find file names matching a shell file name pattern (_not_ a `%' -- pattern). -- *Note The Function `wildcard': Wildcard Function. -- --`$(realpath NAMES...)' -- For each file name in NAMES, expand to an absolute name that does -- not contain any `.', `..', nor symlinks. -- *Note Functions for File Names: File Name Functions. -- --`$(abspath NAMES...)' -- For each file name in NAMES, expand to an absolute name that does -- not contain any `.' or `..' components, but preserves symlinks. -- *Note Functions for File Names: File Name Functions. -- --`$(error TEXT...)' -- When this function is evaluated, `make' generates a fatal error -- with the message TEXT. -- *Note Functions That Control Make: Make Control Functions. -- --`$(warning TEXT...)' -- When this function is evaluated, `make' generates a warning with -- the message TEXT. -- *Note Functions That Control Make: Make Control Functions. -- --`$(shell COMMAND)' -- Execute a shell command and return its output. -- *Note The `shell' Function: Shell Function. -- --`$(origin VARIABLE)' -- Return a string describing how the `make' variable VARIABLE was -- defined. -- *Note The `origin' Function: Origin Function. -- --`$(flavor VARIABLE)' -- Return a string describing the flavor of the `make' variable -- VARIABLE. -- *Note The `flavor' Function: Flavor Function. -- --`$(foreach VAR,WORDS,TEXT)' -- Evaluate TEXT with VAR bound to each word in WORDS, and -- concatenate the results. -- *Note The `foreach' Function: Foreach Function. -- --`$(call VAR,PARAM,...)' -- Evaluate the variable VAR replacing any references to `$(1)', -- `$(2)' with the first, second, etc. PARAM values. -- *Note The `call' Function: Call Function. -- --`$(eval TEXT)' -- Evaluate TEXT then read the results as makefile commands. Expands -- to the empty string. -- *Note The `eval' Function: Eval Function. -- --`$(value VAR)' -- Evaluates to the contents of the variable VAR, with no expansion -- performed on it. -- *Note The `value' Function: Value Function. -- -- Here is a summary of the automatic variables. *Note Automatic --Variables::, for full information. -- --`$@' -- The file name of the target. -- --`$%' -- The target member name, when the target is an archive member. -- --`$<' -- The name of the first prerequisite. -- --`$?' -- The names of all the prerequisites that are newer than the target, -- with spaces between them. For prerequisites which are archive -- members, only the member named is used (*note Archives::). -- --`$^' --`$+' -- The names of all the prerequisites, with spaces between them. For -- prerequisites which are archive members, only the member named is -- used (*note Archives::). The value of `$^' omits duplicate -- prerequisites, while `$+' retains them and preserves their order. -- --`$*' -- The stem with which an implicit rule matches (*note How Patterns -- Match: Pattern Match.). -- --`$(@D)' --`$(@F)' -- The directory part and the file-within-directory part of `$@'. -- --`$(*D)' --`$(*F)' -- The directory part and the file-within-directory part of `$*'. -- --`$(%D)' --`$(%F)' -- The directory part and the file-within-directory part of `$%'. -- --`$( tar-`sed -e '/version_string/!d' \ -- -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \ -- -e q -- version.c`.shar.Z -- -- .PHONY: dist -- dist: $(SRCS) $(AUX) -- echo tar-`sed \ -- -e '/version_string/!d' \ -- -e 's/[^0-9.]*\([0-9.]*\).*/\1/' \ -- -e q -- version.c` > .fname -- -rm -rf `cat .fname` -- mkdir `cat .fname` -- ln $(SRCS) $(AUX) `cat .fname` -- tar chZf `cat .fname`.tar.Z `cat .fname` -- -rm -rf `cat .fname` .fname -- -- tar.zoo: $(SRCS) $(AUX) -- -rm -rf tmp.dir -- -mkdir tmp.dir -- -rm tar.zoo -- for X in $(SRCS) $(AUX) ; do \ -- echo $$X ; \ -- sed 's/$$/^M/' $$X \ -- > tmp.dir/$$X ; done -- cd tmp.dir ; zoo aM ../tar.zoo * -- -rm -rf tmp.dir -- -- --File: make.info, Node: GNU Free Documentation License, Next: Concept Index, Prev: Complex Makefile, Up: Top -- --Appendix D GNU Free Documentation License --***************************************** -- -- Version 1.2, November 2002 -- -- Copyright (C) 2000,2001,2002 Free Software Foundation, Inc. -- 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA -- -- Everyone is permitted to copy and distribute verbatim copies -- of this license document, but changing it is not allowed. -- -- 0. PREAMBLE -- -- The purpose of this License is to make a manual, textbook, or other -- functional and useful document "free" in the sense of freedom: to -- assure everyone the effective freedom to copy and redistribute it, -- with or without modifying it, either commercially or -- noncommercially. Secondarily, this License preserves for the -- author and publisher a way to get credit for their work, while not -- being considered responsible for modifications made by others. -- -- This License is a kind of "copyleft", which means that derivative -- works of the document must themselves be free in the same sense. -- It complements the GNU General Public License, which is a copyleft -- license designed for free software. -- -- We have designed this License in order to use it for manuals for -- free software, because free software needs free documentation: a -- free program should come with manuals providing the same freedoms -- that the software does. But this License is not limited to -- software manuals; it can be used for any textual work, regardless -- of subject matter or whether it is published as a printed book. -- We recommend this License principally for works whose purpose is -- instruction or reference. -- -- 1. APPLICABILITY AND DEFINITIONS -- -- This License applies to any manual or other work, in any medium, -- that contains a notice placed by the copyright holder saying it -- can be distributed under the terms of this License. Such a notice -- grants a world-wide, royalty-free license, unlimited in duration, -- to use that work under the conditions stated herein. The -- "Document", below, refers to any such manual or work. Any member -- of the public is a licensee, and is addressed as "you". You -- accept the license if you copy, modify or distribute the work in a -- way requiring permission under copyright law. -- -- A "Modified Version" of the Document means any work containing the -- Document or a portion of it, either copied verbatim, or with -- modifications and/or translated into another language. -- -- A "Secondary Section" is a named appendix or a front-matter section -- of the Document that deals exclusively with the relationship of the -- publishers or authors of the Document to the Document's overall -- subject (or to related matters) and contains nothing that could -- fall directly within that overall subject. (Thus, if the Document -- is in part a textbook of mathematics, a Secondary Section may not -- explain any mathematics.) The relationship could be a matter of -- historical connection with the subject or with related matters, or -- of legal, commercial, philosophical, ethical or political position -- regarding them. -- -- The "Invariant Sections" are certain Secondary Sections whose -- titles are designated, as being those of Invariant Sections, in -- the notice that says that the Document is released under this -- License. If a section does not fit the above definition of -- Secondary then it is not allowed to be designated as Invariant. -- The Document may contain zero Invariant Sections. If the Document -- does not identify any Invariant Sections then there are none. -- -- The "Cover Texts" are certain short passages of text that are -- listed, as Front-Cover Texts or Back-Cover Texts, in the notice -- that says that the Document is released under this License. A -- Front-Cover Text may be at most 5 words, and a Back-Cover Text may -- be at most 25 words. -- -- A "Transparent" copy of the Document means a machine-readable copy, -- represented in a format whose specification is available to the -- general public, that is suitable for revising the document -- straightforwardly with generic text editors or (for images -- composed of pixels) generic paint programs or (for drawings) some -- widely available drawing editor, and that is suitable for input to -- text formatters or for automatic translation to a variety of -- formats suitable for input to text formatters. A copy made in an -- otherwise Transparent file format whose markup, or absence of -- markup, has been arranged to thwart or discourage subsequent -- modification by readers is not Transparent. An image format is -- not Transparent if used for any substantial amount of text. A -- copy that is not "Transparent" is called "Opaque". -- -- Examples of suitable formats for Transparent copies include plain -- ASCII without markup, Texinfo input format, LaTeX input format, -- SGML or XML using a publicly available DTD, and -- standard-conforming simple HTML, PostScript or PDF designed for -- human modification. Examples of transparent image formats include -- PNG, XCF and JPG. Opaque formats include proprietary formats that -- can be read and edited only by proprietary word processors, SGML or -- XML for which the DTD and/or processing tools are not generally -- available, and the machine-generated HTML, PostScript or PDF -- produced by some word processors for output purposes only. -- -- The "Title Page" means, for a printed book, the title page itself, -- plus such following pages as are needed to hold, legibly, the -- material this License requires to appear in the title page. For -- works in formats which do not have any title page as such, "Title -- Page" means the text near the most prominent appearance of the -- work's title, preceding the beginning of the body of the text. -- -- A section "Entitled XYZ" means a named subunit of the Document -- whose title either is precisely XYZ or contains XYZ in parentheses -- following text that translates XYZ in another language. (Here XYZ -- stands for a specific section name mentioned below, such as -- "Acknowledgements", "Dedications", "Endorsements", or "History".) -- To "Preserve the Title" of such a section when you modify the -- Document means that it remains a section "Entitled XYZ" according -- to this definition. -- -- The Document may include Warranty Disclaimers next to the notice -- which states that this License applies to the Document. These -- Warranty Disclaimers are considered to be included by reference in -- this License, but only as regards disclaiming warranties: any other -- implication that these Warranty Disclaimers may have is void and -- has no effect on the meaning of this License. -- -- 2. VERBATIM COPYING -- -- You may copy and distribute the Document in any medium, either -- commercially or noncommercially, provided that this License, the -- copyright notices, and the license notice saying this License -- applies to the Document are reproduced in all copies, and that you -- add no other conditions whatsoever to those of this License. You -- may not use technical measures to obstruct or control the reading -- or further copying of the copies you make or distribute. However, -- you may accept compensation in exchange for copies. If you -- distribute a large enough number of copies you must also follow -- the conditions in section 3. -- -- You may also lend copies, under the same conditions stated above, -- and you may publicly display copies. -- -- 3. COPYING IN QUANTITY -- -- If you publish printed copies (or copies in media that commonly -- have printed covers) of the Document, numbering more than 100, and -- the Document's license notice requires Cover Texts, you must -- enclose the copies in covers that carry, clearly and legibly, all -- these Cover Texts: Front-Cover Texts on the front cover, and -- Back-Cover Texts on the back cover. Both covers must also clearly -- and legibly identify you as the publisher of these copies. The -- front cover must present the full title with all words of the -- title equally prominent and visible. You may add other material -- on the covers in addition. Copying with changes limited to the -- covers, as long as they preserve the title of the Document and -- satisfy these conditions, can be treated as verbatim copying in -- other respects. -- -- If the required texts for either cover are too voluminous to fit -- legibly, you should put the first ones listed (as many as fit -- reasonably) on the actual cover, and continue the rest onto -- adjacent pages. -- -- If you publish or distribute Opaque copies of the Document -- numbering more than 100, you must either include a -- machine-readable Transparent copy along with each Opaque copy, or -- state in or with each Opaque copy a computer-network location from -- which the general network-using public has access to download -- using public-standard network protocols a complete Transparent -- copy of the Document, free of added material. If you use the -- latter option, you must take reasonably prudent steps, when you -- begin distribution of Opaque copies in quantity, to ensure that -- this Transparent copy will remain thus accessible at the stated -- location until at least one year after the last time you -- distribute an Opaque copy (directly or through your agents or -- retailers) of that edition to the public. -- -- It is requested, but not required, that you contact the authors of -- the Document well before redistributing any large number of -- copies, to give them a chance to provide you with an updated -- version of the Document. -- -- 4. MODIFICATIONS -- -- You may copy and distribute a Modified Version of the Document -- under the conditions of sections 2 and 3 above, provided that you -- release the Modified Version under precisely this License, with -- the Modified Version filling the role of the Document, thus -- licensing distribution and modification of the Modified Version to -- whoever possesses a copy of it. In addition, you must do these -- things in the Modified Version: -- -- A. Use in the Title Page (and on the covers, if any) a title -- distinct from that of the Document, and from those of -- previous versions (which should, if there were any, be listed -- in the History section of the Document). You may use the -- same title as a previous version if the original publisher of -- that version gives permission. -- -- B. List on the Title Page, as authors, one or more persons or -- entities responsible for authorship of the modifications in -- the Modified Version, together with at least five of the -- principal authors of the Document (all of its principal -- authors, if it has fewer than five), unless they release you -- from this requirement. -- -- C. State on the Title page the name of the publisher of the -- Modified Version, as the publisher. -- -- D. Preserve all the copyright notices of the Document. -- -- E. Add an appropriate copyright notice for your modifications -- adjacent to the other copyright notices. -- -- F. Include, immediately after the copyright notices, a license -- notice giving the public permission to use the Modified -- Version under the terms of this License, in the form shown in -- the Addendum below. -- -- G. Preserve in that license notice the full lists of Invariant -- Sections and required Cover Texts given in the Document's -- license notice. -- -- H. Include an unaltered copy of this License. -- -- I. Preserve the section Entitled "History", Preserve its Title, -- and add to it an item stating at least the title, year, new -- authors, and publisher of the Modified Version as given on -- the Title Page. If there is no section Entitled "History" in -- the Document, create one stating the title, year, authors, -- and publisher of the Document as given on its Title Page, -- then add an item describing the Modified Version as stated in -- the previous sentence. -- -- J. Preserve the network location, if any, given in the Document -- for public access to a Transparent copy of the Document, and -- likewise the network locations given in the Document for -- previous versions it was based on. These may be placed in -- the "History" section. You may omit a network location for a -- work that was published at least four years before the -- Document itself, or if the original publisher of the version -- it refers to gives permission. -- -- K. For any section Entitled "Acknowledgements" or "Dedications", -- Preserve the Title of the section, and preserve in the -- section all the substance and tone of each of the contributor -- acknowledgements and/or dedications given therein. -- -- L. Preserve all the Invariant Sections of the Document, -- unaltered in their text and in their titles. Section numbers -- or the equivalent are not considered part of the section -- titles. -- -- M. Delete any section Entitled "Endorsements". Such a section -- may not be included in the Modified Version. -- -- N. Do not retitle any existing section to be Entitled -- "Endorsements" or to conflict in title with any Invariant -- Section. -- -- O. Preserve any Warranty Disclaimers. -- -- If the Modified Version includes new front-matter sections or -- appendices that qualify as Secondary Sections and contain no -- material copied from the Document, you may at your option -- designate some or all of these sections as invariant. To do this, -- add their titles to the list of Invariant Sections in the Modified -- Version's license notice. These titles must be distinct from any -- other section titles. -- -- You may add a section Entitled "Endorsements", provided it contains -- nothing but endorsements of your Modified Version by various -- parties--for example, statements of peer review or that the text -- has been approved by an organization as the authoritative -- definition of a standard. -- -- You may add a passage of up to five words as a Front-Cover Text, -- and a passage of up to 25 words as a Back-Cover Text, to the end -- of the list of Cover Texts in the Modified Version. Only one -- passage of Front-Cover Text and one of Back-Cover Text may be -- added by (or through arrangements made by) any one entity. If the -- Document already includes a cover text for the same cover, -- previously added by you or by arrangement made by the same entity -- you are acting on behalf of, you may not add another; but you may -- replace the old one, on explicit permission from the previous -- publisher that added the old one. -- -- The author(s) and publisher(s) of the Document do not by this -- License give permission to use their names for publicity for or to -- assert or imply endorsement of any Modified Version. -- -- 5. COMBINING DOCUMENTS -- -- You may combine the Document with other documents released under -- this License, under the terms defined in section 4 above for -- modified versions, provided that you include in the combination -- all of the Invariant Sections of all of the original documents, -- unmodified, and list them all as Invariant Sections of your -- combined work in its license notice, and that you preserve all -- their Warranty Disclaimers. -- -- The combined work need only contain one copy of this License, and -- multiple identical Invariant Sections may be replaced with a single -- copy. If there are multiple Invariant Sections with the same name -- but different contents, make the title of each such section unique -- by adding at the end of it, in parentheses, the name of the -- original author or publisher of that section if known, or else a -- unique number. Make the same adjustment to the section titles in -- the list of Invariant Sections in the license notice of the -- combined work. -- -- In the combination, you must combine any sections Entitled -- "History" in the various original documents, forming one section -- Entitled "History"; likewise combine any sections Entitled -- "Acknowledgements", and any sections Entitled "Dedications". You -- must delete all sections Entitled "Endorsements." -- -- 6. COLLECTIONS OF DOCUMENTS -- -- You may make a collection consisting of the Document and other -- documents released under this License, and replace the individual -- copies of this License in the various documents with a single copy -- that is included in the collection, provided that you follow the -- rules of this License for verbatim copying of each of the -- documents in all other respects. -- -- You may extract a single document from such a collection, and -- distribute it individually under this License, provided you insert -- a copy of this License into the extracted document, and follow -- this License in all other respects regarding verbatim copying of -- that document. -- -- 7. AGGREGATION WITH INDEPENDENT WORKS -- -- A compilation of the Document or its derivatives with other -- separate and independent documents or works, in or on a volume of -- a storage or distribution medium, is called an "aggregate" if the -- copyright resulting from the compilation is not used to limit the -- legal rights of the compilation's users beyond what the individual -- works permit. When the Document is included in an aggregate, this -- License does not apply to the other works in the aggregate which -- are not themselves derivative works of the Document. -- -- If the Cover Text requirement of section 3 is applicable to these -- copies of the Document, then if the Document is less than one half -- of the entire aggregate, the Document's Cover Texts may be placed -- on covers that bracket the Document within the aggregate, or the -- electronic equivalent of covers if the Document is in electronic -- form. Otherwise they must appear on printed covers that bracket -- the whole aggregate. -- -- 8. TRANSLATION -- -- Translation is considered a kind of modification, so you may -- distribute translations of the Document under the terms of section -- 4. Replacing Invariant Sections with translations requires special -- permission from their copyright holders, but you may include -- translations of some or all Invariant Sections in addition to the -- original versions of these Invariant Sections. You may include a -- translation of this License, and all the license notices in the -- Document, and any Warranty Disclaimers, provided that you also -- include the original English version of this License and the -- original versions of those notices and disclaimers. In case of a -- disagreement between the translation and the original version of -- this License or a notice or disclaimer, the original version will -- prevail. -- -- If a section in the Document is Entitled "Acknowledgements", -- "Dedications", or "History", the requirement (section 4) to -- Preserve its Title (section 1) will typically require changing the -- actual title. -- -- 9. TERMINATION -- -- You may not copy, modify, sublicense, or distribute the Document -- except as expressly provided for under this License. Any other -- attempt to copy, modify, sublicense or distribute the Document is -- void, and will automatically terminate your rights under this -- License. However, parties who have received copies, or rights, -- from you under this License will not have their licenses -- terminated so long as such parties remain in full compliance. -- -- 10. FUTURE REVISIONS OF THIS LICENSE -- -- The Free Software Foundation may publish new, revised versions of -- the GNU Free Documentation License from time to time. Such new -- versions will be similar in spirit to the present version, but may -- differ in detail to address new problems or concerns. See -- `http://www.gnu.org/copyleft/'. -- -- Each version of the License is given a distinguishing version -- number. If the Document specifies that a particular numbered -- version of this License "or any later version" applies to it, you -- have the option of following the terms and conditions either of -- that specified version or of any later version that has been -- published (not as a draft) by the Free Software Foundation. If -- the Document does not specify a version number of this License, -- you may choose any version ever published (not as a draft) by the -- Free Software Foundation. -- --D.1 ADDENDUM: How to use this License for your documents --======================================================== -- --To use this License in a document you have written, include a copy of --the License in the document and put the following copyright and license --notices just after the title page: -- -- Copyright (C) YEAR YOUR NAME. -- Permission is granted to copy, distribute and/or modify this document -- under the terms of the GNU Free Documentation License, Version 1.2 -- or any later version published by the Free Software Foundation; -- with no Invariant Sections, no Front-Cover Texts, and no Back-Cover -- Texts. A copy of the license is included in the section entitled ``GNU -- Free Documentation License''. -- -- If you have Invariant Sections, Front-Cover Texts and Back-Cover --Texts, replace the "with...Texts." line with this: -- -- with the Invariant Sections being LIST THEIR TITLES, with -- the Front-Cover Texts being LIST, and with the Back-Cover Texts -- being LIST. -- -- If you have Invariant Sections without Cover Texts, or some other --combination of the three, merge those two alternatives to suit the --situation. -- -- If your document contains nontrivial examples of program code, we --recommend releasing these examples in parallel under your choice of --free software license, such as the GNU General Public License, to --permit their use in free software. -- -- --File: make.info, Node: Concept Index, Next: Name Index, Prev: GNU Free Documentation License, Up: Top -- --Index of Concepts --***************** -- --[index] --* Menu: -- --* # (comments), in commands: Command Syntax. (line 27) --* # (comments), in makefile: Makefile Contents. (line 41) --* #include: Automatic Prerequisites. -- (line 16) --* $, in function call: Syntax of Functions. (line 6) --* $, in rules: Rule Syntax. (line 32) --* $, in variable name: Computed Names. (line 6) --* $, in variable reference: Reference. (line 6) --* %, in pattern rules: Pattern Intro. (line 9) --* %, quoting in patsubst: Text Functions. (line 26) --* %, quoting in static pattern: Static Usage. (line 37) --* %, quoting in vpath: Selective Search. (line 38) --* %, quoting with \ (backslash) <1>: Text Functions. (line 26) --* %, quoting with \ (backslash) <2>: Static Usage. (line 37) --* %, quoting with \ (backslash): Selective Search. (line 38) --* * (wildcard character): Wildcards. (line 6) --* +, and command execution: Instead of Execution. -- (line 58) --* +, and commands: MAKE Variable. (line 18) --* +, and define: Sequences. (line 50) --* +=: Appending. (line 6) --* +=, expansion: Reading Makefiles. (line 33) --* ,v (RCS file extension): Catalogue of Rules. (line 164) --* - (in commands): Errors. (line 19) --* -, and define: Sequences. (line 50) --* --always-make: Options Summary. (line 15) --* --assume-new <1>: Options Summary. (line 242) --* --assume-new: Instead of Execution. -- (line 33) --* --assume-new, and recursion: Options/Recursion. (line 22) --* --assume-old <1>: Options Summary. (line 147) --* --assume-old: Avoiding Compilation. -- (line 6) --* --assume-old, and recursion: Options/Recursion. (line 22) --* --check-symlink-times: Options Summary. (line 130) --* --debug: Options Summary. (line 42) --* --directory <1>: Options Summary. (line 26) --* --directory: Recursion. (line 20) --* --directory, and --print-directory: -w Option. (line 20) --* --directory, and recursion: Options/Recursion. (line 22) --* --dry-run <1>: Options Summary. (line 140) --* --dry-run <2>: Instead of Execution. -- (line 14) --* --dry-run: Echoing. (line 18) --* --environment-overrides: Options Summary. (line 78) --* --file <1>: Options Summary. (line 84) --* --file <2>: Makefile Arguments. (line 6) --* --file: Makefile Names. (line 23) --* --file, and recursion: Options/Recursion. (line 22) --* --help: Options Summary. (line 90) --* --ignore-errors <1>: Options Summary. (line 94) --* --ignore-errors: Errors. (line 30) --* --include-dir <1>: Options Summary. (line 99) --* --include-dir: Include. (line 52) --* --jobs <1>: Options Summary. (line 106) --* --jobs: Parallel. (line 6) --* --jobs, and recursion: Options/Recursion. (line 25) --* --just-print <1>: Options Summary. (line 139) --* --just-print <2>: Instead of Execution. -- (line 14) --* --just-print: Echoing. (line 18) --* --keep-going <1>: Options Summary. (line 115) --* --keep-going <2>: Testing. (line 16) --* --keep-going: Errors. (line 47) --* --load-average <1>: Options Summary. (line 122) --* --load-average: Parallel. (line 57) --* --makefile <1>: Options Summary. (line 85) --* --makefile <2>: Makefile Arguments. (line 6) --* --makefile: Makefile Names. (line 23) --* --max-load <1>: Options Summary. (line 123) --* --max-load: Parallel. (line 57) --* --new-file <1>: Options Summary. (line 241) --* --new-file: Instead of Execution. -- (line 33) --* --new-file, and recursion: Options/Recursion. (line 22) --* --no-builtin-rules: Options Summary. (line 175) --* --no-builtin-variables: Options Summary. (line 188) --* --no-keep-going: Options Summary. (line 203) --* --no-print-directory <1>: Options Summary. (line 233) --* --no-print-directory: -w Option. (line 20) --* --old-file <1>: Options Summary. (line 146) --* --old-file: Avoiding Compilation. -- (line 6) --* --old-file, and recursion: Options/Recursion. (line 22) --* --print-data-base: Options Summary. (line 155) --* --print-directory: Options Summary. (line 225) --* --print-directory, and --directory: -w Option. (line 20) --* --print-directory, and recursion: -w Option. (line 20) --* --print-directory, disabling: -w Option. (line 20) --* --question <1>: Options Summary. (line 167) --* --question: Instead of Execution. -- (line 25) --* --quiet <1>: Options Summary. (line 198) --* --quiet: Echoing. (line 24) --* --recon <1>: Options Summary. (line 141) --* --recon <2>: Instead of Execution. -- (line 14) --* --recon: Echoing. (line 18) --* --silent <1>: Options Summary. (line 197) --* --silent: Echoing. (line 24) --* --stop: Options Summary. (line 204) --* --touch <1>: Options Summary. (line 212) --* --touch: Instead of Execution. -- (line 19) --* --touch, and recursion: MAKE Variable. (line 34) --* --version: Options Summary. (line 220) --* --warn-undefined-variables: Options Summary. (line 251) --* --what-if <1>: Options Summary. (line 240) --* --what-if: Instead of Execution. -- (line 33) --* -B: Options Summary. (line 14) --* -b: Options Summary. (line 9) --* -C <1>: Options Summary. (line 25) --* -C: Recursion. (line 20) --* -C, and -w: -w Option. (line 20) --* -C, and recursion: Options/Recursion. (line 22) --* -d: Options Summary. (line 33) --* -e: Options Summary. (line 77) --* -e (shell flag): Automatic Prerequisites. -- (line 66) --* -f <1>: Options Summary. (line 83) --* -f <2>: Makefile Arguments. (line 6) --* -f: Makefile Names. (line 23) --* -f, and recursion: Options/Recursion. (line 22) --* -h: Options Summary. (line 89) --* -I: Options Summary. (line 98) --* -i <1>: Options Summary. (line 93) --* -i: Errors. (line 30) --* -I: Include. (line 52) --* -j <1>: Options Summary. (line 105) --* -j: Parallel. (line 6) --* -j, and archive update: Archive Pitfalls. (line 6) --* -j, and recursion: Options/Recursion. (line 25) --* -k <1>: Options Summary. (line 114) --* -k <2>: Testing. (line 16) --* -k: Errors. (line 47) --* -L: Options Summary. (line 129) --* -l: Options Summary. (line 121) --* -l (library search): Libraries/Search. (line 6) --* -l (load average): Parallel. (line 57) --* -m: Options Summary. (line 10) --* -M (to compiler): Automatic Prerequisites. -- (line 18) --* -MM (to GNU compiler): Automatic Prerequisites. -- (line 68) --* -n <1>: Options Summary. (line 138) --* -n <2>: Instead of Execution. -- (line 14) --* -n: Echoing. (line 18) --* -o <1>: Options Summary. (line 145) --* -o: Avoiding Compilation. -- (line 6) --* -o, and recursion: Options/Recursion. (line 22) --* -p: Options Summary. (line 154) --* -q <1>: Options Summary. (line 166) --* -q: Instead of Execution. -- (line 25) --* -R: Options Summary. (line 187) --* -r: Options Summary. (line 174) --* -S: Options Summary. (line 202) --* -s <1>: Options Summary. (line 196) --* -s: Echoing. (line 24) --* -t <1>: Options Summary. (line 211) --* -t: Instead of Execution. -- (line 19) --* -t, and recursion: MAKE Variable. (line 34) --* -v: Options Summary. (line 219) --* -W: Options Summary. (line 239) --* -w: Options Summary. (line 224) --* -W: Instead of Execution. -- (line 33) --* -w, and -C: -w Option. (line 20) --* -w, and recursion: -w Option. (line 20) --* -W, and recursion: Options/Recursion. (line 22) --* -w, disabling: -w Option. (line 20) --* .a (archives): Archive Suffix Rules. -- (line 6) --* .C: Catalogue of Rules. (line 39) --* .c: Catalogue of Rules. (line 35) --* .cc: Catalogue of Rules. (line 39) --* .ch: Catalogue of Rules. (line 151) --* .cpp: Catalogue of Rules. (line 39) --* .d: Automatic Prerequisites. -- (line 81) --* .def: Catalogue of Rules. (line 74) --* .dvi: Catalogue of Rules. (line 151) --* .F: Catalogue of Rules. (line 49) --* .f: Catalogue of Rules. (line 49) --* .info: Catalogue of Rules. (line 158) --* .l: Catalogue of Rules. (line 124) --* .LIBPATTERNS, and link libraries: Libraries/Search. (line 6) --* .ln: Catalogue of Rules. (line 146) --* .mod: Catalogue of Rules. (line 74) --* .o: Catalogue of Rules. (line 35) --* .p: Catalogue of Rules. (line 45) --* .PRECIOUS intermediate files: Chained Rules. (line 56) --* .r: Catalogue of Rules. (line 49) --* .S: Catalogue of Rules. (line 82) --* .s: Catalogue of Rules. (line 79) --* .sh: Catalogue of Rules. (line 180) --* .sym: Catalogue of Rules. (line 74) --* .tex: Catalogue of Rules. (line 151) --* .texi: Catalogue of Rules. (line 158) --* .texinfo: Catalogue of Rules. (line 158) --* .txinfo: Catalogue of Rules. (line 158) --* .w: Catalogue of Rules. (line 151) --* .web: Catalogue of Rules. (line 151) --* .y: Catalogue of Rules. (line 120) --* :: rules (double-colon): Double-Colon. (line 6) --* := <1>: Setting. (line 6) --* :=: Flavors. (line 56) --* = <1>: Setting. (line 6) --* =: Flavors. (line 10) --* =, expansion: Reading Makefiles. (line 33) --* ? (wildcard character): Wildcards. (line 6) --* ?= <1>: Setting. (line 6) --* ?=: Flavors. (line 129) --* ?=, expansion: Reading Makefiles. (line 33) --* @ (in commands): Echoing. (line 6) --* @, and define: Sequences. (line 50) --* [...] (wildcard characters): Wildcards. (line 6) --* \ (backslash), for continuation lines: Simple Makefile. (line 40) --* \ (backslash), in commands: Splitting Lines. (line 6) --* \ (backslash), to quote % <1>: Text Functions. (line 26) --* \ (backslash), to quote % <2>: Static Usage. (line 37) --* \ (backslash), to quote %: Selective Search. (line 38) --* __.SYMDEF: Archive Symbols. (line 6) --* abspath: File Name Functions. (line 121) --* algorithm for directory search: Search Algorithm. (line 6) --* all (standard target): Goals. (line 72) --* appending to variables: Appending. (line 6) --* ar: Implicit Variables. (line 41) --* archive: Archives. (line 6) --* archive member targets: Archive Members. (line 6) --* archive symbol directory updating: Archive Symbols. (line 6) --* archive, and -j: Archive Pitfalls. (line 6) --* archive, and parallel execution: Archive Pitfalls. (line 6) --* archive, suffix rule for: Archive Suffix Rules. -- (line 6) --* Arg list too long: Options/Recursion. (line 57) --* arguments of functions: Syntax of Functions. (line 6) --* as <1>: Implicit Variables. (line 44) --* as: Catalogue of Rules. (line 79) --* assembly, rule to compile: Catalogue of Rules. (line 79) --* automatic generation of prerequisites <1>: Automatic Prerequisites. -- (line 6) --* automatic generation of prerequisites: Include. (line 50) --* automatic variables: Automatic Variables. (line 6) --* automatic variables in prerequisites: Automatic Variables. (line 17) --* backquotes: Shell Function. (line 6) --* backslash (\), for continuation lines: Simple Makefile. (line 40) --* backslash (\), in commands: Splitting Lines. (line 6) --* backslash (\), to quote % <1>: Text Functions. (line 26) --* backslash (\), to quote % <2>: Static Usage. (line 37) --* backslash (\), to quote %: Selective Search. (line 38) --* backslashes in pathnames and wildcard expansion: Wildcard Pitfall. -- (line 31) --* basename: File Name Functions. (line 57) --* binary packages: Install Command Categories. -- (line 80) --* broken pipe: Parallel. (line 30) --* bugs, reporting: Bugs. (line 6) --* built-in special targets: Special Targets. (line 6) --* C++, rule to compile: Catalogue of Rules. (line 39) --* C, rule to compile: Catalogue of Rules. (line 35) --* cc <1>: Implicit Variables. (line 47) --* cc: Catalogue of Rules. (line 35) --* cd (shell command) <1>: MAKE Variable. (line 16) --* cd (shell command): Execution. (line 10) --* chains of rules: Chained Rules. (line 6) --* check (standard target): Goals. (line 114) --* clean (standard target): Goals. (line 75) --* clean target <1>: Cleanup. (line 11) --* clean target: Simple Makefile. (line 83) --* cleaning up: Cleanup. (line 6) --* clobber (standard target): Goals. (line 86) --* co <1>: Implicit Variables. (line 56) --* co: Catalogue of Rules. (line 164) --* combining rules by prerequisite: Combine By Prerequisite. -- (line 6) --* command line variable definitions, and recursion: Options/Recursion. -- (line 17) --* command line variables: Overriding. (line 6) --* command syntax: Command Syntax. (line 6) --* commands: Rule Syntax. (line 26) --* commands setting shell variables: Execution. (line 10) --* commands, backslash (\) in: Splitting Lines. (line 6) --* commands, comments in: Command Syntax. (line 27) --* commands, echoing: Echoing. (line 6) --* commands, empty: Empty Commands. (line 6) --* commands, errors in: Errors. (line 6) --* commands, execution: Execution. (line 6) --* commands, execution in parallel: Parallel. (line 6) --* commands, expansion: Shell Function. (line 6) --* commands, how to write: Commands. (line 6) --* commands, instead of executing: Instead of Execution. -- (line 6) --* commands, introduction to: Rule Introduction. (line 8) --* commands, quoting newlines in: Splitting Lines. (line 6) --* commands, sequences of: Sequences. (line 6) --* commands, splitting: Splitting Lines. (line 6) --* commands, using variables in: Variables in Commands. -- (line 6) --* comments, in commands: Command Syntax. (line 27) --* comments, in makefile: Makefile Contents. (line 41) --* compatibility: Features. (line 6) --* compatibility in exporting: Variables/Recursion. (line 105) --* compilation, testing: Testing. (line 6) --* computed variable name: Computed Names. (line 6) --* conditional expansion: Conditional Functions. -- (line 6) --* conditional variable assignment: Flavors. (line 129) --* conditionals: Conditionals. (line 6) --* continuation lines: Simple Makefile. (line 40) --* controlling make: Make Control Functions. -- (line 6) --* conventions for makefiles: Makefile Conventions. -- (line 6) --* ctangle <1>: Implicit Variables. (line 107) --* ctangle: Catalogue of Rules. (line 151) --* cweave <1>: Implicit Variables. (line 101) --* cweave: Catalogue of Rules. (line 151) --* data base of make rules: Options Summary. (line 155) --* deducing commands (implicit rules): make Deduces. (line 6) --* default directories for included makefiles: Include. (line 52) --* default goal <1>: Rules. (line 11) --* default goal: How Make Works. (line 11) --* default makefile name: Makefile Names. (line 6) --* default rules, last-resort: Last Resort. (line 6) --* define, expansion: Reading Makefiles. (line 33) --* defining variables verbatim: Defining. (line 6) --* deletion of target files <1>: Interrupts. (line 6) --* deletion of target files: Errors. (line 64) --* directive: Makefile Contents. (line 28) --* directories, printing them: -w Option. (line 6) --* directories, updating archive symbol: Archive Symbols. (line 6) --* directory part: File Name Functions. (line 17) --* directory search (VPATH): Directory Search. (line 6) --* directory search (VPATH), and implicit rules: Implicit/Search. -- (line 6) --* directory search (VPATH), and link libraries: Libraries/Search. -- (line 6) --* directory search (VPATH), and shell commands: Commands/Search. -- (line 6) --* directory search algorithm: Search Algorithm. (line 6) --* directory search, traditional (GPATH): Search Algorithm. (line 42) --* dist (standard target): Goals. (line 106) --* distclean (standard target): Goals. (line 84) --* dollar sign ($), in function call: Syntax of Functions. (line 6) --* dollar sign ($), in rules: Rule Syntax. (line 32) --* dollar sign ($), in variable name: Computed Names. (line 6) --* dollar sign ($), in variable reference: Reference. (line 6) --* DOS, choosing a shell in: Choosing the Shell. (line 36) --* double-colon rules: Double-Colon. (line 6) --* duplicate words, removing: Text Functions. (line 155) --* E2BIG: Options/Recursion. (line 57) --* echoing of commands: Echoing. (line 6) --* editor: Introduction. (line 22) --* Emacs (M-x compile): Errors. (line 62) --* empty commands: Empty Commands. (line 6) --* empty targets: Empty Targets. (line 6) --* environment: Environment. (line 6) --* environment, and recursion: Variables/Recursion. (line 6) --* environment, SHELL in: Choosing the Shell. (line 10) --* error, stopping on: Make Control Functions. -- (line 11) --* errors (in commands): Errors. (line 6) --* errors with wildcards: Wildcard Pitfall. (line 6) --* evaluating makefile syntax: Eval Function. (line 6) --* execution, in parallel: Parallel. (line 6) --* execution, instead of: Instead of Execution. -- (line 6) --* execution, of commands: Execution. (line 6) --* exit status (errors): Errors. (line 6) --* exit status of make: Running. (line 18) --* expansion, secondary: Secondary Expansion. (line 6) --* explicit rule, definition of: Makefile Contents. (line 10) --* explicit rule, expansion: Reading Makefiles. (line 62) --* explicit rules, secondary expansion of: Secondary Expansion. -- (line 106) --* exporting variables: Variables/Recursion. (line 6) --* f77 <1>: Implicit Variables. (line 64) --* f77: Catalogue of Rules. (line 49) --* FDL, GNU Free Documentation License: GNU Free Documentation License. -- (line 6) --* features of GNU make: Features. (line 6) --* features, missing: Missing. (line 6) --* file name functions: File Name Functions. (line 6) --* file name of makefile: Makefile Names. (line 6) --* file name of makefile, how to specify: Makefile Names. (line 30) --* file name prefix, adding: File Name Functions. (line 79) --* file name suffix: File Name Functions. (line 43) --* file name suffix, adding: File Name Functions. (line 68) --* file name with wildcards: Wildcards. (line 6) --* file name, abspath of: File Name Functions. (line 121) --* file name, basename of: File Name Functions. (line 57) --* file name, directory part: File Name Functions. (line 17) --* file name, nondirectory part: File Name Functions. (line 27) --* file name, realpath of: File Name Functions. (line 114) --* files, assuming new: Instead of Execution. -- (line 33) --* files, assuming old: Avoiding Compilation. -- (line 6) --* files, avoiding recompilation of: Avoiding Compilation. -- (line 6) --* files, intermediate: Chained Rules. (line 16) --* filtering out words: Text Functions. (line 132) --* filtering words: Text Functions. (line 114) --* finding strings: Text Functions. (line 103) --* flags: Options Summary. (line 6) --* flags for compilers: Implicit Variables. (line 6) --* flavor of variable: Flavor Function. (line 6) --* flavors of variables: Flavors. (line 6) --* FORCE: Force Targets. (line 6) --* force targets: Force Targets. (line 6) --* Fortran, rule to compile: Catalogue of Rules. (line 49) --* functions: Functions. (line 6) --* functions, for controlling make: Make Control Functions. -- (line 6) --* functions, for file names: File Name Functions. (line 6) --* functions, for text: Text Functions. (line 6) --* functions, syntax of: Syntax of Functions. (line 6) --* functions, user defined: Call Function. (line 6) --* g++ <1>: Implicit Variables. (line 53) --* g++: Catalogue of Rules. (line 39) --* gcc: Catalogue of Rules. (line 35) --* generating prerequisites automatically <1>: Automatic Prerequisites. -- (line 6) --* generating prerequisites automatically: Include. (line 50) --* get <1>: Implicit Variables. (line 67) --* get: Catalogue of Rules. (line 173) --* globbing (wildcards): Wildcards. (line 6) --* goal: How Make Works. (line 11) --* goal, default <1>: Rules. (line 11) --* goal, default: How Make Works. (line 11) --* goal, how to specify: Goals. (line 6) --* home directory: Wildcards. (line 11) --* IEEE Standard 1003.2: Overview. (line 13) --* ifdef, expansion: Reading Makefiles. (line 51) --* ifeq, expansion: Reading Makefiles. (line 51) --* ifndef, expansion: Reading Makefiles. (line 51) --* ifneq, expansion: Reading Makefiles. (line 51) --* implicit rule: Implicit Rules. (line 6) --* implicit rule, and directory search: Implicit/Search. (line 6) --* implicit rule, and VPATH: Implicit/Search. (line 6) --* implicit rule, definition of: Makefile Contents. (line 16) --* implicit rule, expansion: Reading Makefiles. (line 62) --* implicit rule, how to use: Using Implicit. (line 6) --* implicit rule, introduction to: make Deduces. (line 6) --* implicit rule, predefined: Catalogue of Rules. (line 6) --* implicit rule, search algorithm: Implicit Rule Search. -- (line 6) --* implicit rules, secondary expansion of: Secondary Expansion. -- (line 146) --* included makefiles, default directories: Include. (line 52) --* including (MAKEFILE_LIST variable): MAKEFILE_LIST Variable. -- (line 6) --* including (MAKEFILES variable): MAKEFILES Variable. (line 6) --* including other makefiles: Include. (line 6) --* incompatibilities: Missing. (line 6) --* Info, rule to format: Catalogue of Rules. (line 158) --* install (standard target): Goals. (line 92) --* intermediate files: Chained Rules. (line 16) --* intermediate files, preserving: Chained Rules. (line 46) --* intermediate targets, explicit: Special Targets. (line 44) --* interrupt: Interrupts. (line 6) --* job slots: Parallel. (line 6) --* job slots, and recursion: Options/Recursion. (line 25) --* jobs, limiting based on load: Parallel. (line 57) --* joining lists of words: File Name Functions. (line 90) --* killing (interruption): Interrupts. (line 6) --* last-resort default rules: Last Resort. (line 6) --* ld: Catalogue of Rules. (line 86) --* lex <1>: Implicit Variables. (line 71) --* lex: Catalogue of Rules. (line 124) --* Lex, rule to run: Catalogue of Rules. (line 124) --* libraries for linking, directory search: Libraries/Search. (line 6) --* library archive, suffix rule for: Archive Suffix Rules. -- (line 6) --* limiting jobs based on load: Parallel. (line 57) --* link libraries, and directory search: Libraries/Search. (line 6) --* link libraries, patterns matching: Libraries/Search. (line 6) --* linking, predefined rule for: Catalogue of Rules. (line 86) --* lint <1>: Implicit Variables. (line 78) --* lint: Catalogue of Rules. (line 146) --* lint, rule to run: Catalogue of Rules. (line 146) --* list of all prerequisites: Automatic Variables. (line 61) --* list of changed prerequisites: Automatic Variables. (line 51) --* load average: Parallel. (line 57) --* loops in variable expansion: Flavors. (line 44) --* lpr (shell command) <1>: Empty Targets. (line 25) --* lpr (shell command): Wildcard Examples. (line 21) --* m2c <1>: Implicit Variables. (line 81) --* m2c: Catalogue of Rules. (line 74) --* macro: Using Variables. (line 10) --* make depend: Automatic Prerequisites. -- (line 37) --* makefile: Introduction. (line 7) --* makefile name: Makefile Names. (line 6) --* makefile name, how to specify: Makefile Names. (line 30) --* makefile rule parts: Rule Introduction. (line 6) --* makefile syntax, evaluating: Eval Function. (line 6) --* makefile, and MAKEFILES variable: MAKEFILES Variable. (line 6) --* makefile, conventions for: Makefile Conventions. -- (line 6) --* makefile, how make processes: How Make Works. (line 6) --* makefile, how to write: Makefiles. (line 6) --* makefile, including: Include. (line 6) --* makefile, overriding: Overriding Makefiles. -- (line 6) --* makefile, parsing: Reading Makefiles. (line 6) --* makefile, remaking of: Remaking Makefiles. (line 6) --* makefile, simple: Simple Makefile. (line 6) --* makefiles, and MAKEFILE_LIST variable: MAKEFILE_LIST Variable. -- (line 6) --* makefiles, and special variables: Special Variables. (line 6) --* makeinfo <1>: Implicit Variables. (line 88) --* makeinfo: Catalogue of Rules. (line 158) --* match-anything rule: Match-Anything Rules. -- (line 6) --* match-anything rule, used to override: Overriding Makefiles. -- (line 12) --* missing features: Missing. (line 6) --* mistakes with wildcards: Wildcard Pitfall. (line 6) --* modified variable reference: Substitution Refs. (line 6) --* Modula-2, rule to compile: Catalogue of Rules. (line 74) --* mostlyclean (standard target): Goals. (line 78) --* multiple rules for one target: Multiple Rules. (line 6) --* multiple rules for one target (::): Double-Colon. (line 6) --* multiple targets: Multiple Targets. (line 6) --* multiple targets, in pattern rule: Pattern Intro. (line 49) --* name of makefile: Makefile Names. (line 6) --* name of makefile, how to specify: Makefile Names. (line 30) --* nested variable reference: Computed Names. (line 6) --* newline, quoting, in commands: Splitting Lines. (line 6) --* newline, quoting, in makefile: Simple Makefile. (line 40) --* nondirectory part: File Name Functions. (line 27) --* normal prerequisites: Prerequisite Types. (line 6) --* OBJ: Variables Simplify. (line 20) --* obj: Variables Simplify. (line 20) --* OBJECTS: Variables Simplify. (line 20) --* objects: Variables Simplify. (line 14) --* OBJS: Variables Simplify. (line 20) --* objs: Variables Simplify. (line 20) --* old-fashioned suffix rules: Suffix Rules. (line 6) --* options: Options Summary. (line 6) --* options, and recursion: Options/Recursion. (line 6) --* options, setting from environment: Options/Recursion. (line 81) --* options, setting in makefiles: Options/Recursion. (line 81) --* order of pattern rules: Pattern Intro. (line 57) --* order-only prerequisites: Prerequisite Types. (line 6) --* origin of variable: Origin Function. (line 6) --* overriding makefiles: Overriding Makefiles. -- (line 6) --* overriding variables with arguments: Overriding. (line 6) --* overriding with override: Override Directive. (line 6) --* parallel execution: Parallel. (line 6) --* parallel execution, and archive update: Archive Pitfalls. (line 6) --* parallel execution, overriding: Special Targets. (line 135) --* parts of makefile rule: Rule Introduction. (line 6) --* Pascal, rule to compile: Catalogue of Rules. (line 45) --* pattern rule: Pattern Intro. (line 6) --* pattern rule, expansion: Reading Makefiles. (line 62) --* pattern rules, order of: Pattern Intro. (line 57) --* pattern rules, static (not implicit): Static Pattern. (line 6) --* pattern rules, static, syntax of: Static Usage. (line 6) --* pattern-specific variables: Pattern-specific. (line 6) --* pc <1>: Implicit Variables. (line 84) --* pc: Catalogue of Rules. (line 45) --* phony targets: Phony Targets. (line 6) --* pitfalls of wildcards: Wildcard Pitfall. (line 6) --* portability: Features. (line 6) --* POSIX: Overview. (line 13) --* POSIX.2: Options/Recursion. (line 60) --* post-installation commands: Install Command Categories. -- (line 6) --* pre-installation commands: Install Command Categories. -- (line 6) --* precious targets: Special Targets. (line 29) --* predefined rules and variables, printing: Options Summary. (line 155) --* prefix, adding: File Name Functions. (line 79) --* prerequisite: Rules. (line 6) --* prerequisite pattern, implicit: Pattern Intro. (line 22) --* prerequisite pattern, static (not implicit): Static Usage. (line 30) --* prerequisite types: Prerequisite Types. (line 6) --* prerequisite, expansion: Reading Makefiles. (line 62) --* prerequisites: Rule Syntax. (line 46) --* prerequisites, and automatic variables: Automatic Variables. -- (line 17) --* prerequisites, automatic generation <1>: Automatic Prerequisites. -- (line 6) --* prerequisites, automatic generation: Include. (line 50) --* prerequisites, introduction to: Rule Introduction. (line 8) --* prerequisites, list of all: Automatic Variables. (line 61) --* prerequisites, list of changed: Automatic Variables. (line 51) --* prerequisites, normal: Prerequisite Types. (line 6) --* prerequisites, order-only: Prerequisite Types. (line 6) --* prerequisites, varying (static pattern): Static Pattern. (line 6) --* preserving intermediate files: Chained Rules. (line 46) --* preserving with .PRECIOUS <1>: Chained Rules. (line 56) --* preserving with .PRECIOUS: Special Targets. (line 29) --* preserving with .SECONDARY: Special Targets. (line 49) --* print (standard target): Goals. (line 97) --* print target <1>: Empty Targets. (line 25) --* print target: Wildcard Examples. (line 21) --* printing directories: -w Option. (line 6) --* printing messages: Make Control Functions. -- (line 43) --* printing of commands: Echoing. (line 6) --* printing user warnings: Make Control Functions. -- (line 35) --* problems and bugs, reporting: Bugs. (line 6) --* problems with wildcards: Wildcard Pitfall. (line 6) --* processing a makefile: How Make Works. (line 6) --* question mode: Instead of Execution. -- (line 25) --* quoting %, in patsubst: Text Functions. (line 26) --* quoting %, in static pattern: Static Usage. (line 37) --* quoting %, in vpath: Selective Search. (line 38) --* quoting newline, in commands: Splitting Lines. (line 6) --* quoting newline, in makefile: Simple Makefile. (line 40) --* Ratfor, rule to compile: Catalogue of Rules. (line 49) --* RCS, rule to extract from: Catalogue of Rules. (line 164) --* reading makefiles: Reading Makefiles. (line 6) --* README: Makefile Names. (line 9) --* realclean (standard target): Goals. (line 85) --* realpath: File Name Functions. (line 114) --* recompilation: Introduction. (line 22) --* recompilation, avoiding: Avoiding Compilation. -- (line 6) --* recording events with empty targets: Empty Targets. (line 6) --* recursion: Recursion. (line 6) --* recursion, and -C: Options/Recursion. (line 22) --* recursion, and -f: Options/Recursion. (line 22) --* recursion, and -j: Options/Recursion. (line 25) --* recursion, and -o: Options/Recursion. (line 22) --* recursion, and -t: MAKE Variable. (line 34) --* recursion, and -w: -w Option. (line 20) --* recursion, and -W: Options/Recursion. (line 22) --* recursion, and command line variable definitions: Options/Recursion. -- (line 17) --* recursion, and environment: Variables/Recursion. (line 6) --* recursion, and MAKE variable: MAKE Variable. (line 6) --* recursion, and MAKEFILES variable: MAKEFILES Variable. (line 14) --* recursion, and options: Options/Recursion. (line 6) --* recursion, and printing directories: -w Option. (line 6) --* recursion, and variables: Variables/Recursion. (line 6) --* recursion, level of: Variables/Recursion. (line 115) --* recursive variable expansion <1>: Flavors. (line 6) --* recursive variable expansion: Using Variables. (line 6) --* recursively expanded variables: Flavors. (line 6) --* reference to variables <1>: Advanced. (line 6) --* reference to variables: Reference. (line 6) --* relinking: How Make Works. (line 46) --* remaking makefiles: Remaking Makefiles. (line 6) --* removal of target files <1>: Interrupts. (line 6) --* removal of target files: Errors. (line 64) --* removing duplicate words: Text Functions. (line 155) --* removing targets on failure: Special Targets. (line 68) --* removing, to clean up: Cleanup. (line 6) --* reporting bugs: Bugs. (line 6) --* rm: Implicit Variables. (line 110) --* rm (shell command) <1>: Errors. (line 27) --* rm (shell command) <2>: Phony Targets. (line 20) --* rm (shell command) <3>: Wildcard Examples. (line 12) --* rm (shell command): Simple Makefile. (line 83) --* rule commands: Commands. (line 6) --* rule prerequisites: Rule Syntax. (line 46) --* rule syntax: Rule Syntax. (line 6) --* rule targets: Rule Syntax. (line 18) --* rule, double-colon (::): Double-Colon. (line 6) --* rule, explicit, definition of: Makefile Contents. (line 10) --* rule, how to write: Rules. (line 6) --* rule, implicit: Implicit Rules. (line 6) --* rule, implicit, and directory search: Implicit/Search. (line 6) --* rule, implicit, and VPATH: Implicit/Search. (line 6) --* rule, implicit, chains of: Chained Rules. (line 6) --* rule, implicit, definition of: Makefile Contents. (line 16) --* rule, implicit, how to use: Using Implicit. (line 6) --* rule, implicit, introduction to: make Deduces. (line 6) --* rule, implicit, predefined: Catalogue of Rules. (line 6) --* rule, introduction to: Rule Introduction. (line 6) --* rule, multiple for one target: Multiple Rules. (line 6) --* rule, no commands or prerequisites: Force Targets. (line 6) --* rule, pattern: Pattern Intro. (line 6) --* rule, static pattern: Static Pattern. (line 6) --* rule, static pattern versus implicit: Static versus Implicit. -- (line 6) --* rule, with multiple targets: Multiple Targets. (line 6) --* rules, and $: Rule Syntax. (line 32) --* s. (SCCS file prefix): Catalogue of Rules. (line 173) --* SCCS, rule to extract from: Catalogue of Rules. (line 173) --* search algorithm, implicit rule: Implicit Rule Search. -- (line 6) --* search path for prerequisites (VPATH): Directory Search. (line 6) --* search path for prerequisites (VPATH), and implicit rules: Implicit/Search. -- (line 6) --* search path for prerequisites (VPATH), and link libraries: Libraries/Search. -- (line 6) --* searching for strings: Text Functions. (line 103) --* secondary expansion: Secondary Expansion. (line 6) --* secondary expansion and explicit rules: Secondary Expansion. -- (line 106) --* secondary expansion and implicit rules: Secondary Expansion. -- (line 146) --* secondary expansion and static pattern rules: Secondary Expansion. -- (line 138) --* secondary files: Chained Rules. (line 46) --* secondary targets: Special Targets. (line 49) --* sed (shell command): Automatic Prerequisites. -- (line 73) --* selecting a word: Text Functions. (line 159) --* selecting word lists: Text Functions. (line 168) --* sequences of commands: Sequences. (line 6) --* setting options from environment: Options/Recursion. (line 81) --* setting options in makefiles: Options/Recursion. (line 81) --* setting variables: Setting. (line 6) --* several rules for one target: Multiple Rules. (line 6) --* several targets in a rule: Multiple Targets. (line 6) --* shar (standard target): Goals. (line 103) --* shell command: Simple Makefile. (line 72) --* shell command, and directory search: Commands/Search. (line 6) --* shell command, execution: Execution. (line 6) --* shell command, function for: Shell Function. (line 6) --* shell file name pattern (in include): Include. (line 13) --* shell variables, setting in commands: Execution. (line 10) --* shell wildcards (in include): Include. (line 13) --* shell, choosing the: Choosing the Shell. (line 6) --* SHELL, exported value: Variables/Recursion. (line 23) --* SHELL, import from environment: Environment. (line 37) --* shell, in DOS and Windows: Choosing the Shell. (line 36) --* SHELL, MS-DOS specifics: Choosing the Shell. (line 42) --* SHELL, value of: Choosing the Shell. (line 6) --* signal: Interrupts. (line 6) --* silent operation: Echoing. (line 6) --* simple makefile: Simple Makefile. (line 6) --* simple variable expansion: Using Variables. (line 6) --* simplifying with variables: Variables Simplify. (line 6) --* simply expanded variables: Flavors. (line 56) --* sorting words: Text Functions. (line 146) --* spaces, in variable values: Flavors. (line 103) --* spaces, stripping: Text Functions. (line 80) --* special targets: Special Targets. (line 6) --* special variables: Special Variables. (line 6) --* specifying makefile name: Makefile Names. (line 30) --* splitting commands: Splitting Lines. (line 6) --* standard input: Parallel. (line 30) --* standards conformance: Overview. (line 13) --* standards for makefiles: Makefile Conventions. -- (line 6) --* static pattern rule: Static Pattern. (line 6) --* static pattern rule, syntax of: Static Usage. (line 6) --* static pattern rule, versus implicit: Static versus Implicit. -- (line 6) --* static pattern rules, secondary expansion of: Secondary Expansion. -- (line 138) --* stem <1>: Pattern Match. (line 6) --* stem: Static Usage. (line 17) --* stem, variable for: Automatic Variables. (line 77) --* stopping make: Make Control Functions. -- (line 11) --* strings, searching for: Text Functions. (line 103) --* stripping whitespace: Text Functions. (line 80) --* sub-make: Variables/Recursion. (line 6) --* subdirectories, recursion for: Recursion. (line 6) --* substitution variable reference: Substitution Refs. (line 6) --* suffix rule: Suffix Rules. (line 6) --* suffix rule, for archive: Archive Suffix Rules. -- (line 6) --* suffix, adding: File Name Functions. (line 68) --* suffix, function to find: File Name Functions. (line 43) --* suffix, substituting in variables: Substitution Refs. (line 6) --* switches: Options Summary. (line 6) --* symbol directories, updating archive: Archive Symbols. (line 6) --* syntax of commands: Command Syntax. (line 6) --* syntax of rules: Rule Syntax. (line 6) --* tab character (in commands): Rule Syntax. (line 26) --* tabs in rules: Rule Introduction. (line 21) --* TAGS (standard target): Goals. (line 111) --* tangle <1>: Implicit Variables. (line 104) --* tangle: Catalogue of Rules. (line 151) --* tar (standard target): Goals. (line 100) --* target: Rules. (line 6) --* target pattern, implicit: Pattern Intro. (line 9) --* target pattern, static (not implicit): Static Usage. (line 17) --* target, deleting on error: Errors. (line 64) --* target, deleting on interrupt: Interrupts. (line 6) --* target, expansion: Reading Makefiles. (line 62) --* target, multiple in pattern rule: Pattern Intro. (line 49) --* target, multiple rules for one: Multiple Rules. (line 6) --* target, touching: Instead of Execution. -- (line 19) --* target-specific variables: Target-specific. (line 6) --* targets: Rule Syntax. (line 18) --* targets without a file: Phony Targets. (line 6) --* targets, built-in special: Special Targets. (line 6) --* targets, empty: Empty Targets. (line 6) --* targets, force: Force Targets. (line 6) --* targets, introduction to: Rule Introduction. (line 8) --* targets, multiple: Multiple Targets. (line 6) --* targets, phony: Phony Targets. (line 6) --* terminal rule: Match-Anything Rules. -- (line 6) --* test (standard target): Goals. (line 115) --* testing compilation: Testing. (line 6) --* tex <1>: Implicit Variables. (line 91) --* tex: Catalogue of Rules. (line 151) --* TeX, rule to run: Catalogue of Rules. (line 151) --* texi2dvi <1>: Implicit Variables. (line 95) --* texi2dvi: Catalogue of Rules. (line 158) --* Texinfo, rule to format: Catalogue of Rules. (line 158) --* tilde (~): Wildcards. (line 11) --* touch (shell command) <1>: Empty Targets. (line 25) --* touch (shell command): Wildcard Examples. (line 21) --* touching files: Instead of Execution. -- (line 19) --* traditional directory search (GPATH): Search Algorithm. (line 42) --* types of prerequisites: Prerequisite Types. (line 6) --* undefined variables, warning message: Options Summary. (line 251) --* updating archive symbol directories: Archive Symbols. (line 6) --* updating makefiles: Remaking Makefiles. (line 6) --* user defined functions: Call Function. (line 6) --* value: Using Variables. (line 6) --* value, how a variable gets it: Values. (line 6) --* variable: Using Variables. (line 6) --* variable definition: Makefile Contents. (line 22) --* variable references in commands: Variables in Commands. -- (line 6) --* variables: Variables Simplify. (line 6) --* variables, $ in name: Computed Names. (line 6) --* variables, and implicit rule: Automatic Variables. (line 6) --* variables, appending to: Appending. (line 6) --* variables, automatic: Automatic Variables. (line 6) --* variables, command line: Overriding. (line 6) --* variables, command line, and recursion: Options/Recursion. (line 17) --* variables, computed names: Computed Names. (line 6) --* variables, conditional assignment: Flavors. (line 129) --* variables, defining verbatim: Defining. (line 6) --* variables, environment <1>: Environment. (line 6) --* variables, environment: Variables/Recursion. (line 6) --* variables, exporting: Variables/Recursion. (line 6) --* variables, flavor of: Flavor Function. (line 6) --* variables, flavors: Flavors. (line 6) --* variables, how they get their values: Values. (line 6) --* variables, how to reference: Reference. (line 6) --* variables, loops in expansion: Flavors. (line 44) --* variables, modified reference: Substitution Refs. (line 6) --* variables, nested references: Computed Names. (line 6) --* variables, origin of: Origin Function. (line 6) --* variables, overriding: Override Directive. (line 6) --* variables, overriding with arguments: Overriding. (line 6) --* variables, pattern-specific: Pattern-specific. (line 6) --* variables, recursively expanded: Flavors. (line 6) --* variables, setting: Setting. (line 6) --* variables, simply expanded: Flavors. (line 56) --* variables, spaces in values: Flavors. (line 103) --* variables, substituting suffix in: Substitution Refs. (line 6) --* variables, substitution reference: Substitution Refs. (line 6) --* variables, target-specific: Target-specific. (line 6) --* variables, unexpanded value: Value Function. (line 6) --* variables, warning for undefined: Options Summary. (line 251) --* varying prerequisites: Static Pattern. (line 6) --* verbatim variable definition: Defining. (line 6) --* vpath: Directory Search. (line 6) --* VPATH, and implicit rules: Implicit/Search. (line 6) --* VPATH, and link libraries: Libraries/Search. (line 6) --* warnings, printing: Make Control Functions. -- (line 35) --* weave <1>: Implicit Variables. (line 98) --* weave: Catalogue of Rules. (line 151) --* Web, rule to run: Catalogue of Rules. (line 151) --* what if: Instead of Execution. -- (line 33) --* whitespace, in variable values: Flavors. (line 103) --* whitespace, stripping: Text Functions. (line 80) --* wildcard: Wildcards. (line 6) --* wildcard pitfalls: Wildcard Pitfall. (line 6) --* wildcard, function: File Name Functions. (line 107) --* wildcard, in archive member: Archive Members. (line 36) --* wildcard, in include: Include. (line 13) --* wildcards and MS-DOS/MS-Windows backslashes: Wildcard Pitfall. -- (line 31) --* Windows, choosing a shell in: Choosing the Shell. (line 36) --* word, selecting a: Text Functions. (line 159) --* words, extracting first: Text Functions. (line 184) --* words, extracting last: Text Functions. (line 197) --* words, filtering: Text Functions. (line 114) --* words, filtering out: Text Functions. (line 132) --* words, finding number: Text Functions. (line 180) --* words, iterating over: Foreach Function. (line 6) --* words, joining lists: File Name Functions. (line 90) --* words, removing duplicates: Text Functions. (line 155) --* words, selecting lists of: Text Functions. (line 168) --* writing rule commands: Commands. (line 6) --* writing rules: Rules. (line 6) --* yacc <1>: Implicit Variables. (line 75) --* yacc <2>: Catalogue of Rules. (line 120) --* yacc: Sequences. (line 18) --* Yacc, rule to run: Catalogue of Rules. (line 120) --* ~ (tilde): Wildcards. (line 11) -- -- --File: make.info, Node: Name Index, Prev: Concept Index, Up: Top -- --Index of Functions, Variables, & Directives --******************************************* -- --[index] --* Menu: -- --* $%: Automatic Variables. (line 37) --* $(%D): Automatic Variables. (line 129) --* $(%F): Automatic Variables. (line 130) --* $(*D): Automatic Variables. (line 124) --* $(*F): Automatic Variables. (line 125) --* $(+D): Automatic Variables. (line 147) --* $(+F): Automatic Variables. (line 148) --* $(: Last Resort. (line 23) --* .DEFAULT: Special Targets. (line 20) --* .DEFAULT, and empty commands: Empty Commands. (line 16) --* .DEFAULT_GOAL (define default goal): Special Variables. (line 10) --* .DELETE_ON_ERROR <1>: Errors. (line 64) --* .DELETE_ON_ERROR: Special Targets. (line 67) --* .EXPORT_ALL_VARIABLES <1>: Variables/Recursion. (line 99) --* .EXPORT_ALL_VARIABLES: Special Targets. (line 129) --* .FEATURES (list of supported features): Special Variables. (line 65) --* .IGNORE <1>: Errors. (line 30) --* .IGNORE: Special Targets. (line 74) --* .INCLUDE_DIRS (list of include directories): Special Variables. -- (line 98) --* .INTERMEDIATE: Special Targets. (line 43) --* .LIBPATTERNS: Libraries/Search. (line 6) --* .LOW_RESOLUTION_TIME: Special Targets. (line 86) --* .NOTPARALLEL: Special Targets. (line 134) --* .PHONY <1>: Special Targets. (line 8) --* .PHONY: Phony Targets. (line 22) --* .POSIX: Options/Recursion. (line 60) --* .PRECIOUS <1>: Interrupts. (line 22) --* .PRECIOUS: Special Targets. (line 28) --* .SECONDARY: Special Targets. (line 48) --* .SECONDEXPANSION <1>: Special Targets. (line 57) --* .SECONDEXPANSION: Secondary Expansion. (line 6) --* .SILENT <1>: Echoing. (line 24) --* .SILENT: Special Targets. (line 116) --* .SUFFIXES <1>: Suffix Rules. (line 61) --* .SUFFIXES: Special Targets. (line 15) --* .VARIABLES (list of variables): Special Variables. (line 56) --* /usr/gnu/include: Include. (line 52) --* /usr/include: Include. (line 52) --* /usr/local/include: Include. (line 52) --* < (automatic variable): Automatic Variables. (line 43) --* : Flavors. (line 84) --* MAKE: MAKE Variable. (line 6) --* MAKE_RESTARTS (number of times make has restarted): Special Variables. -- (line 49) --* MAKE_VERSION: Features. (line 197) --* MAKECMDGOALS: Goals. (line 30) --* makefile: Makefile Names. (line 7) --* Makefile: Makefile Names. (line 7) --* MAKEFILE_LIST: MAKEFILE_LIST Variable. -- (line 6) --* MAKEFILES <1>: Variables/Recursion. (line 127) --* MAKEFILES: MAKEFILES Variable. (line 6) --* MAKEFLAGS: Options/Recursion. (line 6) --* MAKEINFO: Implicit Variables. (line 87) --* MAKELEVEL <1>: Flavors. (line 84) --* MAKELEVEL: Variables/Recursion. (line 115) --* MAKEOVERRIDES: Options/Recursion. (line 49) --* MAKESHELL (MS-DOS alternative to SHELL): Choosing the Shell. -- (line 25) --* MFLAGS: Options/Recursion. (line 65) --* notdir: File Name Functions. (line 27) --* or: Conditional Functions. -- (line 37) --* origin: Origin Function. (line 6) --* OUTPUT_OPTION: Catalogue of Rules. (line 202) --* override: Override Directive. (line 6) --* patsubst <1>: Text Functions. (line 18) --* patsubst: Substitution Refs. (line 28) --* PC: Implicit Variables. (line 84) --* PFLAGS: Implicit Variables. (line 153) --* prefix: Directory Variables. (line 25) --* realpath: File Name Functions. (line 114) --* RFLAGS: Implicit Variables. (line 156) --* RM: Implicit Variables. (line 110) --* sbindir: Directory Variables. (line 59) --* shell: Shell Function. (line 6) --* SHELL: Choosing the Shell. (line 6) --* SHELL (command execution): Execution. (line 6) --* sort: Text Functions. (line 146) --* strip: Text Functions. (line 80) --* subst <1>: Text Functions. (line 9) --* subst: Multiple Targets. (line 28) --* suffix: File Name Functions. (line 43) --* SUFFIXES: Suffix Rules. (line 81) --* TANGLE: Implicit Variables. (line 104) --* TEX: Implicit Variables. (line 91) --* TEXI2DVI: Implicit Variables. (line 94) --* unexport: Variables/Recursion. (line 45) --* value: Value Function. (line 6) --* vpath: Selective Search. (line 6) --* VPATH: General Search. (line 6) --* vpath: Directory Search. (line 6) --* VPATH: Directory Search. (line 6) --* warning: Make Control Functions. -- (line 35) --* WEAVE: Implicit Variables. (line 98) --* wildcard <1>: File Name Functions. (line 107) --* wildcard: Wildcard Function. (line 6) --* word: Text Functions. (line 159) --* wordlist: Text Functions. (line 168) --* words: Text Functions. (line 180) --* YACC: Implicit Variables. (line 74) --* YFLAGS: Implicit Variables. (line 150) --* | (automatic variable): Automatic Variables. (line 69) -- -- -diff -rNU3 dist.orig/doc/make.texi dist/doc/make.texi ---- dist.orig/doc/make.texi 2006-04-01 08:36:40.000000000 +0200 -+++ dist/doc/make.texi 2014-08-18 08:47:47.000000000 +0200 -@@ -4,7 +4,7 @@ - - @include version.texi - @set EDITION 0.70 --@set RCSID $Id: make.texi,v 1.45 2006/04/01 06:36:40 psmith Exp $ -+@set RCSID $Id: make.texi,v 1.1.1.1 2014/08/18 06:47:47 christos Exp $ - - @settitle GNU @code{make} - @setchapternewpage odd -diff -rNU3 dist.orig/po/Makefile.in.in dist/po/Makefile.in.in ---- dist.orig/po/Makefile.in.in 2006-04-01 08:39:51.000000000 +0200 -+++ dist/po/Makefile.in.in 2014-08-18 08:57:25.000000000 +0200 -@@ -13,7 +13,7 @@ - PACKAGE = @PACKAGE@ - VERSION = @VERSION@ - --SHELL = /bin/sh -+SHELL = @SHELL@ - @SET_MAKE@ - - srcdir = @srcdir@ -diff -rNU3 dist.orig/tests/scripts/functions/foreach dist/tests/scripts/functions/foreach ---- dist.orig/tests/scripts/functions/foreach 2006-03-10 03:20:46.000000000 +0100 -+++ dist/tests/scripts/functions/foreach 2014-08-18 08:47:57.000000000 +0200 -@@ -1,5 +1,5 @@ - # -*-perl-*- --# $Id: foreach,v 1.5 2006/03/10 02:20:46 psmith Exp $ -+# $Id: foreach,v 1.1.1.1 2014/08/18 06:47:57 christos Exp $ - - $description = "Test the foreach function."; - -diff -rNU3 dist.orig/tests/test_driver.pl dist/tests/test_driver.pl ---- dist.orig/tests/test_driver.pl 2006-03-10 03:20:45.000000000 +0100 -+++ dist/tests/test_driver.pl 2014-08-18 08:47:57.000000000 +0200 -@@ -28,7 +28,7 @@ - # this routine controls the whole mess; each test suite sets up a few - # variables and then calls &toplevel, which does all the real work. - --# $Id: test_driver.pl,v 1.19 2006/03/10 02:20:45 psmith Exp $ -+# $Id: test_driver.pl,v 1.1.1.1 2014/08/18 06:47:57 christos Exp $ - - - # The number of test categories we've run -diff -rNU3 dist.orig/w32/include/sub_proc.h dist/w32/include/sub_proc.h ---- dist.orig/w32/include/sub_proc.h 2006-02-11 23:16:05.000000000 +0100 -+++ dist/w32/include/sub_proc.h 2014-08-18 08:47:56.000000000 +0200 -@@ -21,11 +21,11 @@ - /* - * Component Name: - * -- * $Date: 2006/02/11 22:16:05 $ -+ * $Date: 2014/08/18 06:47:56 $ - * -- * $Source: /sources/make/make/w32/include/sub_proc.h,v $ -+ * $Source: /cvsroot/src/external/gpl2/gmake/dist/w32/include/sub_proc.h,v $ - * -- * $Id: sub_proc.h,v 1.8 2006/02/11 22:16:05 psmith Exp $ -+ * $Id: sub_proc.h,v 1.1.1.1 2014/08/18 06:47:56 christos Exp $ - */ - - #define EXTERN_DECL(entry, args) extern entry args diff --git a/external/gpl2/gmake/patches/0001-support-latest-glibc.patch b/external/gpl2/gmake/patches/0001-support-latest-glibc.patch deleted file mode 100644 index 089a87ca4..000000000 --- a/external/gpl2/gmake/patches/0001-support-latest-glibc.patch +++ /dev/null @@ -1,36 +0,0 @@ -diff -rNU3 dist.orig/configure dist/configure ---- dist.orig/configure 2006-04-01 08:40:00.000000000 +0200 -+++ dist/configure 2018-08-21 21:28:59.000000000 +0200 -@@ -13622,7 +13622,7 @@ - #define GLOB_INTERFACE_VERSION 1 - #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1 - # include --# if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION -+# if _GNU_GLOB_INTERFACE_VERSION >= GLOB_INTERFACE_VERSION - gnu glob - # endif - #endif -diff -rNU3 dist.orig/configure.in dist/configure.in ---- dist.orig/configure.in 2018-08-21 21:29:42.000000000 +0200 -+++ dist/configure.in 2018-08-21 21:29:24.000000000 +0200 -@@ -354,7 +354,7 @@ - #define GLOB_INTERFACE_VERSION 1 - #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1 - # include --# if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION -+# if _GNU_GLOB_INTERFACE_VERSION >= GLOB_INTERFACE_VERSION - gnu glob - # endif - #endif -diff -rNU3 dist.orig/glob/glob.c dist/glob/glob.c ---- dist.orig/glob/glob.c 2006-03-10 03:20:45.000000000 +0100 -+++ dist/glob/glob.c 2018-08-21 21:28:17.000000000 +0200 -@@ -51,7 +51,7 @@ - #define GLOB_INTERFACE_VERSION 1 - #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1 - # include --# if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION -+# if _GNU_GLOB_INTERFACE_VERSION >= GLOB_INTERFACE_VERSION - # define ELIDE_CODE - # endif - #endif diff --git a/tools/gmake/Makefile b/tools/gmake/Makefile deleted file mode 100644 index 544847343..000000000 --- a/tools/gmake/Makefile +++ /dev/null @@ -1,18 +0,0 @@ -# $NetBSD: Makefile,v 1.4 2014/08/18 06:58:51 christos Exp $ -# - -GNUHOSTDIST= ${.CURDIR}/../../external/gpl2/gmake/dist - -CONFIGURE_ENV+= CC=${HOST_CC:Q} \ - CFLAGS=${HOST_CFLAGS:Q} \ - CPPFLAGS=${HOST_CPPFLAGS:Q} \ - CXX=${HOST_CXX:Q} - -CONFIGURE_ARGS= --program-prefix=${_TOOL_PREFIX}g -CONFIGURE_ARGS+=--disable-nls - -MAKE_ARGS= MAKEINFO=${TOOL_MAKEINFO:Q} - -.NOTPARALLEL: - -.include "${.CURDIR}/../Makefile.gnuhost"