Make命令完全详解教程

Make命令完全详解教程

无论是在Linux还是在Unix环境中，make都是一个非常重要的编译命令。不管是自己进行项目开发还是安装应用软件，我们都经常要用到make或make install。利用make工具，我们可以将大型的开发项目分解成为多个更易于管理的模块，对于一个包括几百个源文件的应用程序，使用make和makefile工具就可以简洁明快地理顺各个源文件之间纷繁复杂的相互关系。而且如此多的源文件，如果每次都要键入gcc命令进行编译的话，那对程序员来说简直就是一场灾难。而make工具则可自动完成编译工作，并且可以只对程序员在上次编译后修改过的部分进行编译。因此，有效的利用make和makefile工具可以大大提高项目开发的效率。同时掌握make和makefile之后，您也不会再面对着Linux下的应用软件手足无措了。

一、Make程序的命令行选项和参数

Make命令参数的典型序列如下所示：

make [-f makefile文件名][选项][宏定义][目标]

这里用[]括起来的表示是可选的。命令行选项由破折号“–”指明，后面跟选项，如

make –e

如果需要多个选项，可以只使用一个破折号，如

make –kr

也可以每个选项使用一个破折号，如

make –k –r

甚至混合使用也行，如

make –e –kr

Make命令本身的命令行选项较多，这里只介绍在开发程序时最为常用的三个，它们是：

–k：

如果使用该选项，即使make程序遇到错误也会继续向下运行；如果没有该选项，在遇到第一个错误时make程序马上就会停止，那么后面的错误情况就不得而知了。我们可以利用这个选项来查出所有有编译问题的源文件。

–n：

该选项使make程序进入非执行模式，也就是说将原来应该执行的命令输出，而不是执行。

–f ：

指定作为makefile的文件的名称。 如果不用该选项，那么make程序首先在当前目录查找名为makefile的文件，如果没有找到，它就会转而查找名为Makefile的文件。如果您在Linux下使用GNU Make的话，它会首先查找GNUmakefile，之后再搜索makefile和Makefile。按照惯例，许多Linux程序员使用Makefile，因为这样能使Makefile出现在目录中所有以小写字母命名的文件的前面。所以，最好不要使用GNUmakefile这一名称，因为它只适用于make程序的GNU版本。

当我们想构建指定目标的时候，比如要生成某个可执行文件，那么就可以在make命令行中给出该目标的名称；如果命令行中没有给出目标的话，make命令会设法构建makefile中的第一个目标。我们可以利用这一特点，将all作为makefile中的第一个目标，然后将让目标作为all所依赖的目标，这样，当命令行中没有给出目标时，也能确保它会被构建。

二、Makefile概述

上面提到，make命令对于构建具有多个源文件的程序有很大的帮助。事实上，只有make命令还是不够的，前面说过还必用须makefile告诉它要做什么以及怎么做才行，对于程序开发而言，就是告诉make命令应用程序的组织情况。

我们现在对makefile的位置和数量简单说一下。一般情况下，makefile会跟项目的源文件放在同一个目录中。另外，系统中可以有多个makefile，一般说来一个项目使用一个makefile就可以了；如果项目很大的话，我们就可以考虑将它分成较小的部分，然后用不同的makefile来管理项目的不同部分。

make命令和Makefile配合使用，能给我们的项目管理带来极大的便利，除了用于管理源代码的编译之外，还用于建立手册页，同时还能将应用程序安装到指定的目录。

因为Makefile用于描述系统中模块之间的相互依赖关系，以及产生目标文件所要执行的命令，所以，一个makefile由依赖关系和规则两部分内容组成。下面分别加以解释。

依赖关系由一个目标和一组该目标所依赖的源文件组成。这里所说的目标就是将要创建或更新的文件，最常见的是可执行文件。规则用来说明怎样使用所依赖得文件来建立目标文件。

当make命令运行时，会读取makefile来确定要建立的目标文件或其他文件，然后对源文件的日期和时间进行比较，从而决定使用那些规则来创建目标文件。一般情况下，在建立起最终的目标文件之前，肯定免不了要建立一些中间性质的目标文件。这时，Make命令也是使用makefile来确定这些目标文件的创建顺序，以及用于它们的规则序列。

2.1.Makefile中的依赖关系

make程序自动生成和维护通常是可执行模块或应用程序的目标，目标的状态取决于它所依赖的那些模块的状态。Make的思想是为每一块模块都设置一个时间标记，然后根据时间标记和依赖关系来决定哪一些文件需要更新。一旦依赖模块的状态改变了，make就会根据时间标记的新旧执行预先定义的一组命令来生成新的目标。

依赖关系规定了最终得到的应用程序跟生成它的各个源文件之间的关系。如下面的图1描述了可执行文件main对所有的源程序文件及其编译产生的目标文件之间的依赖关系，见下图：

图1  模块间的依赖关系

就图1而言，我们可以说可执行程序main依赖于main.o、f1.o和ff1.o。与此同时，main.o依赖于main.c和def1.h；f1.o依赖于f1.c、def1.h和def2.h；而ff1.o则依赖于ff1.c、def2.h和def3. h。在makefile中，我们可以用目标名称，加冒号，后跟空格键或tab键，再加上由空格键或tab键分隔的一组用于生产目标模块的文件来描述模块之间的依赖关系对于上例来说，可以作以下描述：

main: main.o f1.o f2.o

main.o: main.c def1.h

f1.o: f1.c def1.h def2.h

f2.o: f2.c def2.h def3.h

不难发现，上面的各个源文件跟各模块之间的关系具有一个明显的层次结构，如果def2.h发生了变化，那么就需要更新f1.o和f2.o，而f1.o和f2.o发生了变化的话，那么main也需要随之重新构建。

默认时，make程序只更新makefile中的第一个目标，如果希望更新多个目标文件的话，可以使用一个特殊的目标all，假如我们想在一个makefile中更新main和hello这两个程序文件的话，可以加入下列语句达到这个目的：

all: main hello

实际上，makefile是以相关行为基本单位的，相关行用来描述目标、模块及规则（即命令行）三者之间的关系。一个相关行格式通常为：冒号左边是目标（模块）名；冒号右边是目标所依赖的模块名；紧跟着的规则（即命令行）是由依赖模块产生目标所使用的命令。相关行的格式为：

目标：[依赖模块][;命令]

习惯上写成多行形式，如下所示：

目标：[依赖模块]

命令

命令

目标（TARGET）程序产生的文件，如可执行文件和目标文件；目标也可以是要执行的动作，如“clean”。

依赖（DEPENDENCIES）是用来产生目标的输入文件，一个目标通常依赖于多个文件。

命令（COMMAND）是make执行的动作，一个可以有多个命令，每个占一行。注意：每个命令行的起始字符必须为TAB字符！

有依赖关系规则中的命令通常在依赖文件变化时负责产生target文件，make执行这些命令更新或产生target。规则可以没有依赖关系，如包含target “clean”的规则。

规则解释如何和何时重做该规则中的文件，make根据依赖关系执行产生或更新目标；规则也说明如何和何时执行动作。有的规则看起来很复杂，但都符合上述模式。

需要注意的是，如果相关行写成一行，“命令”之前用分号“；”隔开，如果分成多行书写的话，后续的行务必以tab字符为先导。对于makefile而言，空格字符和tab字符是不同的。所有规则所在的行必须以tab键开头，而不是空格键。初学者一定对此保持警惕，因为这是新手最容易疏忽的地方，因为几个空格键跟一个tab键在肉眼是看不出区别的，但make命令却能明察秋毫。

此外，如果在makefile文件中的行尾加上空格键的话，也会导致make命令运行失败。所以，大家一定要小心了，免得耽误许多时间。

例，一个名为prog的程序由三个C源文件filea.c、fileb.c和filec.c以及库文件LS编译生成，这三个文件还分别包含自己的头文件a.h 、b.h和c.h。通常情况下，C编译器将会输出三个目标文件filea.o、fileb.o和filec.o。假设filea.c和fileb.c都要声明用到一个名为defs的文件，但filec.c不用。即在filea.c和fileb.c里都有这样的声明：

　#include "defs"

　　那么下面的文档就描述了这些文件之间的相互联系:

line　

1   #It is a example for describing makefile

2　　　prog : filea.o fileb.o filec.o

3　　　cc filea.o fileb.o filec.o -LS -o prog

4　　　filea.o : filea.c a.h defs

5　　　cc -c filea.c

6　　　fileb.o : fileb.c b.h defs

7　　　cc -c fileb.c

8　　　filec.o : filec.c c.h

9　　  cc -c filec.c

这个描述文档就是一个简单的makefile文件。

从上面的例子注意到，第一个字符为 # 的行为注释行。第一个非注释行指定prog由三个目标文件filea.o、fileb.o和filec.o链接生成。第三行描述了如何从prog所依赖的文件建立可执行文件。接下来的4、6、8行分别指定三个目标文件，以及它们所依赖的.c和.h文件以及defs文件。而5、7、9行则指定了如何从目标所依赖的文件建立目标。

 当filea.c或a.h文件在编译之后又被修改，则 make 工具可自动重新编译filea.o，如果在前后两次编译之间，filea.C 和a.h 均没有被修改，而且 test.o 还存在的话，就没有必要重新编译。这种依赖关系在多源文件的程序编译中尤其重要。通过这种依赖关系的定义，make 工具可避免许多不必要的编译工作。当然，利用 Shell 脚本也可以达到自动编译的效果，但是，Shell 脚本将全部编译任何源文件，包括哪些不必要重新编译的源文件，而 make 工具则可根据目标上一次编译的时间和目标所依赖的源文件的更新时间而自动判断应当编译哪个源文件。

2.2.Makefile文件举例

根据图1的依赖关系，这里给出了一个完整的makefile文件，这个例子很简单，由四个相关行组成，我们将其命名为mymakefile1。文件内容如下所示：

main: main.o f1.o f2.o

gcc -o main main.o f1.o f2.o

main.o: main.c def1.h

gcc -c main.c

f1.o: f1.c def1.h def2.h

gcc -c f1.c

f2.o: f2.c def2.h def3.h

gcc -c f2.c

注意，由于我们这里没有使用缺省名makefile 或者Makefile ，所以一定要在make命令行中加上-f选项。如果在没有任何源码的目录下执行命令“make -f Mymakefile1”的话，将收到下面的消息：

make: *** No rule to make target ‘main.c’, needed by ‘main.o’. Stop.

Make命令将makefile中的第一个目标即main作为要构建的文件，所以它会寻找构建该文件所需要的其他模块，并判断出必须使用一个称为main.c的文件。因为迄今尚未建立该文件，而makefile又不知道如何建立它，所以只好报告错误。好了，现在建立这个源文件，为简单起见，我们让头文件为空，创建头文件的具体命令如下：

$ touch def1.h

$ touch def2.h

$ touch def3.h

我们将main函数放在main.c文件中，让它调用function2和function3，但将这两个函数的定义放在另外两个源文件中。由于这些源文件含有#include命令，所以它们肯定依赖于所包含的头文件。如下所示：

/* main.c */

#include

#include “def1.h”

extern void function2();

extern void function3();

int main()

{

function2();

function3();

exit (EXIT_SUCCESS);

}

/* f1.c */

#include “def1.h”

#include “def2.h”

void function2() {

}

/* f2.c */

#include “def2.h”

#include “def3.h”

void function3()

建好源代码后，再次运行make程序，看看情况如何：

$ make -f Mymakefile1

gcc -c main.c

gcc -c f1.c

gcc -c f2.c

gcc -o main main.o f1.o f2.o

$

好了，这次顺利通过了。这说明Make命令已经正确处理了makefile描述的依赖关系，并确定出了需要建立哪些文件，以及它们的建立顺序。虽然我们在makefile 中首先列出的是如何建立main，但是make还是能够正确的判断出这些文件的处理顺序，并按相应的顺序调用规则部分规定的相应命令来创建这些文件。当这些命令执行时，make程序会按照执行情况来显示这些命令。

如今，我们对def2.h加以变动，来看看makefile能否对此作出相应的回应：

$ touch def2.h

$ make -f Mymakefile1

gcc -c f1.c

gcc -c f2.c

gcc -o main main.o f1.o f2.o

$

这说明，当Make命令读取makefile 后，只对受def2.h的变化的影响的模块进行了必要的更新，注意它的更新顺序，它先编译了C程序，最后连接生产了可执行文件。现在，让我们来看看删除目标文件后会发生什么情况，先执行删除，命令如下：

$ rm f1.o

然后运行make命令，如下所示：

$ make -f Mymakefile1

gcc -c f1.c

gcc -o main main.o f1.o f2.o

$

很好，make的行为让我们非常满意。

2.3.Makefile中的宏

在makefile中可以使用诸如XLIB、UIL等类似于Shell变量的标识符，这些标识符在makefile中称为“宏”，它可以代表一些文件名或选项。宏的作用类似于C语言中的define，利用它们来代表某些多处使用而又可能发生变化的内容，可以节省重复修改的工作，还可以避免遗漏。

Make的宏分为两类，一类是用户自己定义的宏，一类是系统内部定义的宏。用户定义的宏必须在makefile或命令行中明确定义，系统定义的宏不由用户定义。我们首先介绍第一种宏。

这里是一个包含宏的makefile文件，我们将其命名为mymakefile2，如下所示：

all: main

# 使用的编译器

CC = gcc

#包含文件所在目录

INCLUDE = .

# 在开发过程中使用的选项

CFLAGS = -g -Wall –ansi

# 在发行时使用的选项

# CFLAGS = -O -Wall –ansi

main: main.o f1.o f2.o

$(CC) -o main main.o f1.o f2.o

main.o: main.c def1.h

$(CC) -I$(INCLUDE) $(CFLAGS) -c main.c

f1.o: f1.c def1.h def2.h

$(CC) -I$(INCLUDE) $(CFLAGS) -c f1.c

f2.o: f2.c def2.h def3.h

$(CC) -I$(INCLUDE) $(CFLAGS) -c f2.c

我们看到，在这里有一些注释。在makefile中，注释以#为开头，至行尾结束。注释不仅可以帮助别人理解我们的makefile，如果时间久了，有些东西我们自己也会忘掉，它们对makefile的编写者来说也是很有必要的。

现在言归正传，先看一下宏的定义。我们既可以在make命令行中定义宏，也可以在makefile中定义宏。

2.4.在makefile中定义宏的基本语法是：

宏标识符=值列表

其中，宏标识符即宏的名称通常全部大写，但它实际上可以由大、小写字母、阿拉伯数字和下划线构成。等号左右的空白符没有严格要求，因为它们最终将被make删除。至于值列表，既可以是零项，也可以是一项或者多项。如：

LIST_VALUE = one two three

当一个宏定义之后，我们就可以通过$(宏标识符)或者${宏标识符}来访问这个标识符所代表的值了。

在makefile中，宏经常用作编译器的选项。很多时候，处于开发阶段的应用程序在编译时是不用优化的，但是却需要调试信息；而正式版本的应用程序却正好相反，没有调试信息的代码不仅所占内存较小，进过优化的代码运行起来也更快。

对于Mymakefile1来说，它假定所用的编译器是gcc，不过在其他的UNIX系统上，更常用的编译器是cc或者c89，而非gcc。如果你想让自己的makefile适用于不同的UNIX操作系统，或者在一个系统上使用其他种类的编译器，这时就不得不对这个makefile中的多处进行修改。

但对于mymakefile2来说则不存在这个问题，我们只需修改一处，即宏定义的值就行了。除了在makefile中定义宏的值之外，我们还可以在make命令行中加以定义，如：

$ make CC=c89

当命令行中的宏定义跟makefile中的定义有冲突时，以命令行中的定义为准。当在makefile文件之外使用时，宏定义必须作为单个参数进行传递，所以要避免使用空格，但是更妥当的方法是使用引号，如：

$ make “CC =   c89”

这样就不必担心空格所引起的问题了。现在让我们将前面的编译结果删掉，来测试一下mymakefile2的工作情况。命令如下所示：

$ rm *.o main

$ make -f Mymakefile2

gcc -I. -g -Wall -ansi -c main.c

gcc -I. -g -Wall -ansi -c f1.c

gcc -I. -g -Wall -ansi -c f2.c

gcc -o main main.o f1.o f2.o

$

就像我们看到的那样，Make程序会用相应的定义来替换宏引用$(CC )、$(CFLAGS )和$(INCLUDE)，这跟C语言中的宏的用法比较相似。

上面介绍了用户定义的宏，现在介绍make的内部宏。常用的内部宏有：

$? ：比目标的修改时间更晚的那些依赖模块表。

$@ ：当前目标的全路径名。可用于用户定义的目标名的相关行中。

$< ：比给定的目标文件时间标记更新的依赖文件名。

$* ：去掉后缀的当前目标名。例如，若当前目标是pro.o，则$*表示pro。

Makefile文件作为一种描述文档一般需要包含以下内容:

　　◆ 宏定义

　　◆ 源文件之间的相互依赖关系

　　◆ 可执行的命令

Makefile中允许使用简单的宏指代源文件及其相关编译信息，在Linux中也称宏为变量。在引用宏时只需在变量前加$符号，但值得注意的是，如果变量名的长度超过一个字符，在引用时就必须加圆括号（）。

下面都是有效的宏引用：

　　$(CFLAGS)

　　$2

　　$Z

　　$(Z)

其中最后两个引用是完全一致的。

需要注意的是一些宏的预定义变量，在Unix系统中，$*、$@、$?和$ bigoutput

littleoutput : text.g

generate text.g -little > littleoutput等同。这里假设程序’generate’产生两种输出：一种使用’-big’选项，一种使用’-little’选项。如果想象使用’$@’变化命令那样来变化依赖关系，不能通过多目标的普通规则实现，但是可以通过模式规则来实现。

3.10.一个目标多条规则

一个文件可以是多条规则的目标，所有规则的依赖关系被合并。如果目标比任一个依赖文件旧，命令被执行。

一个文件只能有一组命令执行。如果多个规则对于同一个文件都给出了命令，make使用最后一组并打印错误信息（特殊情况：如果文件名以’.’开始，并不打印错误信息，这一点是为了和其它make兼容）。没有任何理由需要将makefile写成这样，这是make给出错误信息的理由。

一条只有依赖关系的附加规则可以一次给出许多文件的附加依赖文件。例如’objects’变量表示系统中编译器的所有输出.，说明当’config.h’更改时所有文件必须重做的简单方法如下：

objects = foo.o bar.o

foo.o : defs.h

bar.o : defs.h test.h

$(objects) : config.h

不用改变实际目标文件生成的规则，这条规则可以在需要增删附加的依赖关系时插入或提出。另一个诀窍是附加的依赖关系可以用变量表示，

在make执行时，可以给变量赋值：

extradeps=

$(objects) : $(extradeps)

当命令`make extradeps=foo.h'执行时会认为’foo.h’是每个目标文件的依赖文件，但简单的’make’命令不是这样。

3.11.静态模式规则

静态模式规则（static pattern rules）可以指定多个目标，并且使用目标名字来建议依赖文件的名字；比普通多目标规则更通用因为不需要依赖关系是相同的：依赖关系必须类似但不需要相同。

3.11.1.语法

TARGETS ...: TARGET-PATTERN: DEP-PATTERNS ...

COMMANDS

...

TARGETS列表指出规则应用的目标，可以包含通配符，于普通规则的目标相同。TARGET-PATTERN和DEP-PATTERNS来表明目标的依赖关系如何计算：匹配TARGET-PATTERN的目标从名字中抽出一部分，叫做词干（stem），词干被替换到DEP-PATTERNS来形成依赖文件名。

每个模式通常包含一个’%’字符。当TARGET-PATTERN匹配一个目标时，’%’字符可以匹配目标名中的任何部分；这部分即是词干，模式的其余部分必须完全匹配。例如’foo.o’匹配’%.o’，’foo’是词干；目标’foo.c’和’foo.out’并不匹配这个模式。

目标的依赖文件名通过将DEP-PATTERNS中的’%’替换为词干形成：如果依赖模式为’%.c’，在替换词干’foo’可以得到’foo.c’。依赖模式中不包含’%’也是合法的，此依赖文件对所有的目标均有效。

如果需要在模式规则中使用’%’字符，必须在其前面加’’字符，如果’%’前的’’字符是有实际意义的，必须在其前面加’’，其它的’’不必如此处理。如’the\%weird\%pattern’在有效的’%’前是’the%weird’，其后是’pattern’。最后的’’保持原样是因为其并不影响’%’字符。

以下例子从相应的’.c’文件编译’foo.o’和’bar.o’：

objects = foo.o bar.o

$(objects): %.o: %.c

$(CC) -c $(CFLAGS) $< -o $@

每个目标必须匹配目标模式，对于不匹配的目标会给出警告。如果列表中只有部分文件匹配模式，可以使用filter函数移去不匹配的文件名：

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 $

另一个形式使用续行符：

foo : bar/lose

cd bar;

gobble lose > ../foo

shell程序的名字是通过’SHELL’变量来取得的。

（*UNIX）不象大多数变量，’SHELL’变量不是通过环境来设置的（即需要在makefile中设置），因为’SHELL’环境是个人选择的，如果不同人的选择会影响makefile的功能的话，这样很糟糕。

4.3.并行执行

GNU make可以一次执行几条命令。通常make一次执行一条命令，等待其返回，再执行下一条。使用’-j’或’—jobs’可以同时执行多条命令。如果’-j’后梗一个正数，表示一次可以执行的命令条数；如果’-j’之后没有参数，则不限制可执行的命令数。缺省的数量是一。

一个讨厌的问题是如果同时执行多条命令，它们的输出会混在一起；另一个问题是两个进程不能从同一个设备获得输入。

4.4.错误

每条shell命令返回时，make会检查其返回状态。如果命令执行成功，则下一条命令被执行，最后一条命令执行完后，规则执行结束。

如果有错误（返回非0状态），make放弃当前规则，也可能是所有规则。

有时候命令执行错误并不是问题，比如使用’mkdir’命令确保目录存在：如果目录一存在，则’mkdir’会报告错误，但仍希望make继续。

要忽略命令的错误，在命令之前使用’-‘字符，’-‘字符在传递给shell之前被丢弃：

clean:

-rm -f *.o

如果使用’-i’或’—ignore-errors’选项，make会忽略所有命令产生的错误；一条没有依赖关系的’.IGNORE’规则有相同的作用，但’-‘更灵活。

在忽略错误时，make将错误也认为是成功，只是通知你命令的退出状态和和错误被忽略。如果make并未告知忽略错误，在错误发生时，表明该目标不能成功更新，直接或间接依赖于此的目标当然也不能成功；这些目标的命令不会被执行，因为其先决条件不满足。

通常make会立即以非0状态退出。然而，如果给定’-k’或’—keep-going’选项，make在退出前会处理其它的依赖关系，进行必要的更新。例如，在编译一个目标文件遇到错误，’make -k’会继续编译其它的目标文件。

通常认为你的目的是更新指定的目标，当make知道这是不可能时，会立即报告失败；’-k’选项指示真正目的是测试更新程序的更多可能性：在编译之前找出更多不相关的问题。

如果命令失败了，假设它更新的目标文件，这个文件是不完整的不能使用－至少不是完全更新的。但文件的最后修改时间表明停已经是最新的，下一次make运行时，不会再更新这个文件。这种情况和命令被kill相同；则通常情况下在命令失败时将目标删除是正确的；当’.DELETE_ON_ERROR’是目标时make帮你做这件事。虽然你总是希望make这么做，但这不是过去的习惯；所以必须显式要求make这样做（其它的make自动这样做）。

4.5.中断make

如果make执行命令时遇到错误，可能会删除命令更新的目标文件： make检查文件的修改时间是否变化。删除目标的目的是确保make下次执行时重新生成它。为什么这样做？假设在编译器运行时按了’Ctrl-c’，此时编译器写生成目标文件’foo.o’。’Ctrl-c’ kill了编译器，留下一个不完整的文件，但它的修改时间比源文件’foo.c’新；此时make也受到’Ctrl-c’信号删除这个不完整的文件，如果make不这样做，下次make运行时认为’foo.o’不需要更新，会在链接时出现奇怪的错误。

可以使用’.PRECIOUS’规则来防止目标文件被删除。在make更新目标时，会检测其是否为’.PRECIOUS’的依赖，决定在命令出错或中断时是否删除该目标。如果你希望目标的更新是原子操作，或是用来记录修改时间，或必须一直存在防止其它类型的错误，这些理由使得你必须这样做。

4.6.递归使用

递归使用make就是在makefile中使用make命令。这种技术在你将一个大系统分解为几个子系统，为每个自系统提供一个makefile时有用处。比如有一个子目录’subdir’中有自己的makefile，希望make在自目录中运行，可以这样做：

subsystem:

cd subdir; $(MAKE)

或者

subsystem:

$(MAKE) -C subdir

可以照抄这个；例子来递归使用make

4.6.1.‘MAKE’变量

递归的make必须使用’MAKE’变量，不是显式的make命令：

subsystem:

cd subdir; $(MAKE)

该变量的值是被调用的make的名字。在命令中使用’MAKE’有特殊的功能：它改变了`-t' (`--touch')， `-n' (`--just-print')和`-q' (`--question')选项的含义。使用上例来考虑’make –t’命令（’-t’选项将目标标记为最新但不运行命令），更加’-t’选项的功能，该命令将创建一个’subsystem’文件，实际希望的操作是运行’cd subdir; make –t’；但这会执行命令，与’-t’的原意不符。

这个特殊功能做了期望的工作。当命令行包含变量’MAKE’时，选项’-t’，’-n’和’-q’并不适用。不管这些导致不会执行命令的标志，包含’MAKE’变量的命令始终会执行。正常的’MAKEFLAGS’机制将这些标志传递到子make，这样打印命令的请求被传播到子系统中。

4.6.2.传递变量到子make

上级（top-level）make中的变量可以显式通过环境传递到子make中。在子make中，这些变量被缺省定义，但不会重载子makefile中的定义除非使用’-e’选项。为向下传递，或输出变量，make在运行命令时将其加入到环境变量中；子make，可以使用环境变量来初始化变量表。除非显式要求，make只输出初始环境中或命令行设置的变量而且变量名只由字母，数字和下划线组成。一些shell不能处理有其它字符的环境变量。

特殊变量’SHELL’，’MAKEFLAGS’总是输出，如果’MAKEFILE’变量有值，也会输出。Make自动通过’MAKEFLAGS’来输出命令行定义的变量。

如果想要输出特定变量，使用’export’指令：

export VARIABLE ...

如果要阻止输出一个变量，使用’unexport’指令：

unexport VARIABLE ...

为方便起见，可以在定义变量时输出它：

export VARIABLE = value

和

VARIABLE = value

export VARIABLE

作用相同。

如果要输出所有的变量，使用’export’指令本身就可以了。

变量’MAKELEVEL’在一级一级传递时会改变，这个变量的值是表示嵌套层数的字符串，顶级’make’是，变量的值为’0’；子make的值为’1’；子子make的值为’2’，依此类推。

‘MAKELEVEL’的用途是在条件指令中测试它，这样写出在递归运行时和直接运行时表现不同的makefile。

附：

以下内容拷贝自GNU Make Manual

命令行参数

`-b'

`-m'

These options are ignored for compatibility with other versions of

`make'.

`-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'

`--debug'

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.

`-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.

`-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.

`-I DIR'

`--include-dir=DIR'

Specifies a directory DIR to search for included makefiles. 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.

`-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

dependencies of these targets can be processed all the same.

`-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.

`-n'

`--just-print'

`--dry-run'

`--recon'

Print the commands that would be executed, but do not execute them.

`-o FILE'

`--old-file=FILE'

`--assume-old=FILE'

Do not remake the file FILE even if it is older than its

dependencies, and do not remake anything on account of changes in

FILE. Essentially the file is treated as very old and its rules

are ignored.

`-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 -p -f /dev/null'.

`-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.

`-r'

`--no-builtin-rules'

Eliminate use of the built-in implicit rules.You can still define your own by writing

pattern rules. The `-r' option also clears out the default list

of suffixes for suffix rules .But you can still define your own suffixes with a

rule for `.SUFFIXES', and then define your own suffix rules.

`-s'

`--silent'

`--quiet'

Silent operation; do not print the commands as they are executed.

`-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' 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'.

`-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.

`--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.

`-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'.

`--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.

指令

`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.

`include FILE'

Include another makefile.

`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.

`export'

Tell `make' to export all variables to child processes by default.

`export VARIABLE'

`export VARIABLE = VALUE'

`export VARIABLE := VALUE'

`export VARIABLE += VALUE'

`unexport VARIABLE'

Tell `make' whether or not to export a particular variable to child

processes.

`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.

函数

`$(subst FROM,TO,TEXT)'

Replace FROM with TO in TEXT.

`$(patsubst PATTERN,REPLACEMENT,TEXT)'

Replace words matching PATTERN with REPLACEMENT in TEXT.

`$(strip STRING)'

Remove excess whitespace characters from STRING.

`$(findstring FIND,TEXT)'

Locate FIND in TEXT.

`$(filter PATTERN...,TEXT)'

Select words in TEXT that match one of the PATTERN words.

`$(filter-out PATTERN...,TEXT)'

Select words in TEXT that *do not* match any of the PATTERN words.

`$(sort LIST)'

Sort the words in LIST lexicographically, removing duplicates.

`$(dir NAMES...)'

Extract the directory part of each file name.

`$(notdir NAMES...)'

Extract the non-directory part of each file name.

`$(suffix NAMES...)'

Extract the suffix (the last `.' and following characters) of each

file name.

`$(basename NAMES...)'

Extract the base name (name without suffix) of each file name.

`$(addsuffix SUFFIX,NAMES...)'

Append SUFFIX to each word in NAMES.

`$(addprefix PREFIX,NAMES...)'

Prepend PREFIX to each word in NAMES.

`$(join LIST1,LIST2)'

Join two parallel lists of words.

`$(word N,TEXT)'

Extract the Nth word (one-origin) of TEXT.

`$(words TEXT)'

Count the number of words in TEXT.

`$(firstword NAMES...)'

Extract the first word of NAMES.

`$(wildcard PATTERN...)'

Find file names matching a shell file name pattern (*not* a `%'

pattern).

`$(shell COMMAND)'

Execute a shell command and return its output.

`$(origin VARIABLE)'

Return a string describing how the `make' variable VARIABLE was

defined.

`$(foreach VAR,WORDS,TEXT)'

Evaluate TEXT with VAR bound to each word in WORDS, and

concatenate the results.

自动变量

`$@'

The file name of the target.

`$%'

The target member name, when the target is an archive member.

`$