跟我一起写Makefile笔记总结

跟我一起写Makefile笔记总结

前言

注：本文主要参考学习《跟我一起写Makefile》做的一些笔记，也会参考网上的相关资料做一些补充及案例的讲解。

一 概述

一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile 定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile 就像一个 Shell 脚本一样，其中也可以执行操作系统的命令。 makefile 带来的好处就是——“自动化编译”，一旦写好，只需要一个 make 命令，整个工程完全自动编译，极大的提高了软件开发的效率。make 是一个命令工具，是一个解释 makefile 中指令的命令工具 。

Makefile 文件注意要点：

（1）在工程目录下创建名为“Makefile”的文件，文件名一定要叫做“Makefile”！！！区分大小写。

（2）所有行首需要空出来的地方一定要使用“TAB”键！不要使用空格键！这是Makefile 的语法要求。

一般建立工程的方法有以下三点：

（1）makefile：
优点：使用非常广泛，通用性强，可跨平台。
缺点：语法比较蛋疼。要写出一个通用，便于管理，且兼容性强的makefile比较困难。

（2）cmake：
优点：简单易用，使用较广泛，方便管理，可跨平台。
缺点：自动生成的makefile太臃肿。

（3）sh脚本：
优点：自由，高度定制。简单易用，可操作性强。方便维护。（甚至还可以生成makefile）
缺点：sh建的工程太少（估计没人这么搞）

二 关于程序的编译和链接

源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成 Object File。而在链接程序时，链接器会在所有的 Object File 中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在 VC 下，这种错误一般是：Link 2001 错误，意思说是说，链接器未能找到函数的实现。你需要指定函数的Object File 。

三 Makefile介绍

在 Makefile 中，目标文件（target）包含：执行文件 edit 和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h 文件。每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。

在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个 Tab 键作为开头。

make 并不管命令是怎么工作的，他只管执行所定义的命令。make 会比较 targets 文件和 prerequisites 文件的修改日期，如果 prerequisites 文件的日期要比 targets 文件的日期要新，或者 target 不存在的话，那么，make 就会执行后续定义的命令。

这里要说明一点的是，clean 不是一个文件，它只不过是一个动作名字，有点像 C 语言中的 lable 一样，其冒号后什么也没有，那么，make 就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。要执行其后的命令，就要在 make 命令后明显得指出这个lable 的名字。这样的方法非常有用，我们可以在一个 makefile 中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份，等等。

3.1 make是如何工作的

在默认的方式下，也就是我们只输入 make 命令。那么，
1、make 会在当前目录下找名字叫“Makefile”或“makefile”的文件。
2、如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“edit”这个文件，并把这个文件作为最终的目标文件。
3、 如果 edit 文件不存在， 或是 edit 所依赖的后面的 .o 文件的文件修改时间要比 edit这个文件新，那么，他就会执行后面所定义的命令来生成 edit 这个文件。
4、如果 edit 所依赖的.o 文件也存在，那么 make 会在当前文件中找目标为.o 文件的依赖性，如果找到则再根据那一个规则生成.o 文件。 （这有点像一个堆栈的过程）
5、 当然，你的 C 文件和 H 文件是存在的啦， 于是 make 会生成 .o 文件， 然后再用 .o 文件生成make 的终极任务，也就是执行文件 edit 了。

这就是整个 make 的依赖性，make 会一层又一层地去找文件的依赖关系，直到最终编译 出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make 就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make 根本不理。

3.2 makefile 中使用变量

objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o

于是，我们就可以很方便地在我们的 makefile 中以“$(objects)”的方式来使用这个变量了。

反斜杠（\）是换行符的意思。这样比较便于 Makefile 的易读 。

3.3 让 make 自动推导

GNU 的 make 很强大，它可以自动推导文件以及文件依赖关系后面的命令，于是我们就没必要去在每一个[.o]文件后都写上类似的命令，因为，我们的 make 会自动识别，并自己推导命令。

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)

**这种方法，也就是 make 的“隐晦规则”。上面文件内容中，“.PHONY”表示，clean是个伪目标文件。 **

3.4 清空目标文件的规则

每个 Makefile 中都应该写一个清空目标文件（.o 和执行文件）的规则，这不仅便于重编译，也很利于保持文件的清洁。

一般的风格都是：

clean:
rm edit $(objects)

更为稳健的做法是：

.PHONY : clean
clean :
-rm edit $(objects)

.PHONY 意思表示 clean 是一个“伪目标” 。而在 rm 命令前面加了一个小减号的意思是，也许某些文件出现问题，但不要管，继续做后面的事。当然，clean 的规则不要放在文件的开头，不然，这就会变成 make 的默认目标 。

四 Makefile总述

4.1 Makefile 里有什么？

Makefile 里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。

1、显式规则。
显式规则说明了，如何生成一个或多的的目标文件。这是由 Makefile 的书写者明显指
出，要生成的文件，文件的依赖文件，生成的命令。

2、隐晦规则。
由于我们的 make 有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书
写 Makefile，这是由 make 所支持的。
3、变量的定义。
在 Makefile 中我们要定义一系列的变量，变量一般都是字符串，这个有点你 C 语言中
的宏，当 Makefile 被执行时，其中的变量都会被扩展到相应的引用位置上。
4、文件指示。
其包括了三个部分，一个是在一个 Makefile 中引用另一个 Makefile，就像 C 语言中的
include 一样；另一个是指根据某些情况指定 Makefile 中的有效部分，就像 C 语言中的预
编译#if 一样；还有就是定义一个多行的命令。有关这一部分的内容，我会在后续的部分中
讲述。
5、注释。
Makefile 中只有行注释，和 UNIX 的 Shell 脚本一样，其注释是用“#”字符，这个就
像 C/C++中的“//”一样。如果你要在你的 Makefile 中使用“#”字符，可以用反斜框进行
转义，如：“#”。
最后，还值得一提的是，在 Makefile 中的命令，必须要以[Tab]键开始。

4.2 Makefile 的文件名

默认的情况下，make 命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、“makefile”、“Makefile”的文件，找到了解释这个文件。在这三个文件名中，最好使用“Makefile”这个文件名，因为，这个文件名第一个字符为大写，这样有一种显目的感觉。最好不要用“GNUmakefile”，这个文件是 GNU 的 make 识别的。有另外一些 make 只对全小写的“makefile”文件名敏感，但是基本上来说，大多数的 make 都支持“makefile”和“Makefile”这两种默认文件名。

当 然 ， 你 可 以 使 用 别 的 文 件 名 来 书 写 Makefile ， 比 如 ： “ Make.Linux” ，
“Make.Solaris”，“Make.AIX”等，如果要指定特定的 Makefile，你可以使用 make 的
“-f”和“–file”参数，如：

make -f Make.Linux 

或

make --file Make.AIX

4.3 引用其它的 Makefile

在 Makefile 使用 include 关键字可以把别的 Makefile 包含进来，这很像 C 语言的#include，被包含的文件会原模原样的放在当前文件的包含位置。include 的语法是：

include <filename>

filename 可以是当前操作系统 Shell 的文件模式（可以保含路径和通配符） 在 include前面可以有一些空字符，但是绝不能是[Tab]键开始。include 和可以用一个或多个空格隔开。举个例子，你有这样几个 Makefile：a.mk、b.mk、c.mk，还有一个文件叫foo.make，以及一个变量$(bar)，其包含了 e.mk 和 f.mk，那么，下面的语句：

include foo.make *.mk $(bar)

等价于：

include foo.make a.mk b.mk c.mk e.mk f.mk

make 命令开始时，会把找寻 include 所指出的其它 Makefile，并把其内容安置在当前的位置。就好像 C/C++的#include 指令一样。如果文件都没有指定绝对路径或是相对路径的话，make 会在当前目录下首先寻找，如果当前目录下没有找到，那么，make 还会在下面的几个目录下找：

1、如果 make 执行时，有“-I”或“–include-dir”参数，那么 make 就会在这个参数所指定的目录下去寻找。

2、如果目录/include（一般是：/usr/local/bin 或/usr/include）存在的话，make 也会去找。如果有文件没有找到的话，make 会生成一条警告信息，但不会马上出现致命错误。它会继续载入其它的文件，一旦完成 makefile 的读取，make 会再重试这些没有找到，或是不能读取的文件，如果还是不行，make 才会出现一条致命信息。如果你想让 make不理那些无法读取的文件，而继续执行，你可以在 include 前加一个减号“-”。

如：

-include <filename>  

4.4 环境变量 MAKEFILES

如果你的当前环境中定义了环境变量 MAKEFILES，那么，make 会把这个变量中的值做一个类似于 include 的动作。这个变量中的值是其它的 Makefile，用空格分隔。只是， 它和 include不同的是，从这个环境变中引入的 Makefile 的“目标”不会起作用，如果环境变量中定义的文件发现错误，make 也会不理。

建议不要使用这个环境变量，因为只要这个变量一被定义，那么当你使用 make 时， 所有的 Makefile 都会受到它的影响，也许有时候你的 Makefile 出现了怪事，那么你可以看看当前环境中有没有定义这个变量 。

4.5 make 的工作方式

GNU 的 make 工作时的执行步骤入下：

1、读入所有的 Makefile。
2、读入被 include 的其它 Makefile。
3、初始化文件中的变量。
4、推导隐晦规则，并分析所有规则。
5、为所有的目标文件创建依赖关系链。
6、根据依赖关系，决定哪些目标要重新生成。
7、执行生成命令。

五 Makefile书写规则

规则包含两个部分，一个是依赖关系，一个是生成目标的方法。

在 Makefile 中，规则的顺序是很重要的，因为，Makefile 中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让 make 知道你的最终目标是什么。

一般来说，定义在 Makefile 中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。

5.1 规则语法

targets : prerequisites
	command
...

#或是这样：

targets : prerequisites ; command
	command
...

targets 是文件名，以空格分开，可以使用通配符。一般来说，我们的目标基本上是一个文件，但也有可能是多个文件。

command 是命令行，如果其不与“target:prerequisites”在一行，那么，必须以[Tab键]开头， 如果和 prerequisites 在一行， 那么可以用分号做为分隔。

prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，
目标就被认为是“过时的”，被认为是需要重生成的。

如果命令太长，你可以使用反斜框（‘\’）作为换行符。make 对一行上有多少个字符没有限制。规则告诉 make 两件事，文件的依赖关系和如何成成目标文件。

一般来说，make 会以 UNIX 的标准 Shell，也就是/bin/sh 来执行命令。

5.2 在规则中使用通配符

make 支持三各通配符： “*”，“?”和“[…]”。

波浪号（“_{”）字符在文件名中也有比较特殊的用途。如果是“}/test”，这就表示当前用户的$HOME 目录下的 test 目录。而“~hchen/test”则表示用户 hchen 的宿主目录下的 test 目录。

而在 Windows 或是 MS-DOS 下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。

通配符代替了你一系列的文件，如“*.c”表示所以后缀为 c 的文件。一个需要我们注意的是，如果我们的文件名中有通配符，如：“*”，那么可以用转义字符“\”，如“*”来表示真实的“*”字符，而不是任意长度的字符串。

Makefile 中的变量其实就是 C/C++中的宏。如果你要让通配符在变量中展开，也就是让 objects 的值是所有[.o]的文件名的集合，那么，你可以这样：

objects := $(wildcard *.o)

这种用法由关键字“wildcard”指出 。

5.3 文件搜寻

在一些大的工程中，有大量的源文件，我们通常的做法是把这许多的源文件分类，并存放在不同的目录中。所以，当 make 需要去找寻文件的依赖关系时，你可以在文件前加上路径，但最好的方法是把一个路径告诉 make，让 make 在自动去找。

Makefile 文件中的特殊变量“VPATH”就是完成这个功能的，如果没有指明这个变量，make 只会在当前的目录中去找寻依赖文件和目标文件。如果定义了这个变量，那么，make就会在当当前目录找不到的情况下，到所指定的目录中去找寻文件了。

VPATH = src:../headers

上面的的定义指定两个目录，“src”和“…/headers”，make 会按照这个顺序进行搜索。目录由“冒号”分隔。 （当然，当前目录永远是最高优先搜索的地方） 。

另一个设置文件搜索路径的方法是使用 make 的“vpath”关键字（注意，它是全小写的），这不是变量，这是一个 make 的关键字，这和上面提到的那个 VPATH 变量很类似，但是它更为灵活。它可以指定不同的文件在不同的搜索目录中。 它的使用方法有三种：

1、vpath
为符合模式的文件指定搜索目录。
2、vpath
清除符合模式的文件的搜索目录。
3、vpath
清除所有已被设置好了的文件搜索目录。

vapth 使用方法中的需要包含“%”字符。“%”的意思是匹配零或若干字符，例如，“%.h”表示所有以“.h”结尾的文件。指定了要搜索的文件集，而则指定了的文件集的搜索的目录。例如：

vpath %.h ../headers

该语句表示，要求 make 在“…/headers”目录下搜索所有以“.h”结尾的文件。（如果某文件在当前目录没有找到的话）

我们可以连续地使用 vpath 语句，以指定不同搜索策略。如果连续的 vpath 语句中出现了相同的，或是被重复了的，那么，make 会按照 vpath 语句的先后顺序来执行搜索。如：

#其表示“.c”结尾的文件，先在“foo”目录，然后是“blish”，最后是“bar”目录。
vpath %.c foo
vpath % blish
vpath %.c bar

#而上面的语句则表示“.c”结尾的文件，先在“foo”目录，然后是“bar”目录，最后才是“blish”目录。
vpath %.c foo:bar
vpath % blish

5.4 伪目标

clean:
rm *.o temp

因为，我们并不生成“clean”这个文件。“伪目标”并不是一个文件，只是一个标签，由于“伪目标”不是文件，所以 make 无法生成它的依赖关系和决定它是否要执行。我们只有通过显示地指明这个“目标”才能让其生效。当然，“伪目标”的取名不能和文件名重名，不然其就失去了“伪目标”的意义了。

为了避免和文件重名的这种情况，我们可以使用一个特殊的标记“.PHONY”来显示地指明一个目标是“伪目标”，向 make 说明，不管是否有这个文件，这个目标就是“伪目标”。

.PHONY : clean

伪目标一般没有依赖的文件。但是，我们也可以为伪目标指定所依赖的文件。 Makefile 中的第一个目标会被作为其默认目标，由于伪目标的特性是，总是被执行的。

5.5 多目标

有可能我们的多个目标同时依赖于一个文件，并且其生成的命令大体类似。于是我们就能把其合并起来。 例如：

bigoutput littleoutput : text.g
generate text.g -$(subst output,,$@) > $@

等价于

bigoutput : text.g
generate text.g -big > bigoutput
littleoutput : text.g
generate text.g -little > littleoutput

5.6 静态模式

静态模式可以更加容易地定义多目标的规则，可以让我们的规则变得更加的有弹性和灵活 。

#语法
<targets ...>: <target-pattern>: <prereq-patterns ...>
<commands>
....

#targets 定义了一系列的目标文件，可以有通配符。是目标的一个集合。
#target-parrtern 是指明了 targets 的模式，也就是的目标集模式。
#prereq-parrterns 是目标的依赖模式，它对 target-parrtern 形成的模式再进行一次依赖目标的定义。

我们的“目标模式”或是“依赖模式”中都应该有“%”这个字符，如果你的文件名中有“%”那么你可以使用反斜杠“\”进行转义，来标明真实的“%”字符

#例子

objects = foo.o bar.o

#指明了我们的目标从$object 中获取
all: $(objects)

#“%.o”表明要所有以“.o”结尾的目标，也就是“foo.o bar.o”，也就是变量$object 集合的模式
#而依赖模式“%.c”则取模式“%.o”的“%”，也就是“foo bar”，并为其加下“.c”的后缀，
#于是，我们的依赖目标就是“foo.c bar.c”。
$(objects): %.o: %.c

#命令中的“$<”和“$@”则是自动化变量，“$<”表示所有的依赖目标集（也就是“foo.c bar.c”），
#“$@”表示目标集（也就是“foo.o bar.o”）。
$(CC) -c $(CFLAGS) $< -o $@

#例子

files = foo.elc bar.o lose.o

#表示调用 Makefile 的 filter 函数，过滤“$filter”集，只要其中模式为“%.o”的内容。
$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<

5.7 自动生成依赖性

如果是一个比较大型的工程，你必需清楚哪些 C 文件包含了哪些头文件，并且，你在加入或删除头文件时，也需要小心地修改 Makefile，这是一个很没有维护性的工作。为了避免这种繁重而又容易出错的事情，我们可以使用 C/C++编译的一个功能。大多数的C/C++编译器都支持一个“-M”的选项，即自动找寻源文件中包含的头文件，并生成一个依赖关系。

如果你使用 GNU 的 C/C++编译器，你得用“-MM”参数，不然，“-M”参数会把一些标准库的头文件也包含进来。

GNU 组织建议把编译器为每一个源文件的自动生成的依赖关系放到一个文件中，为每一个“name.c”的文件都生成一个“name.d”的 Makefile 文件，[.d]文件中就存放对应[.c]文件的依赖关系。于是，我们可以写出[.c]文件和[.d]文件的依赖关系，并让 make 自动更新或自成[.d]文件，并把其包含在我们的主 Makefile 中，这样，我们就可以自动化地生成每个文件的依赖关系了。这里，我们给出了一个模式规则来产生[.d]文件：

#所有的[.d]文件依赖于[.c]文件
%.d: %.c

#“rm -f $@”的意思是删除所有的目标，也就是[.d]文件
@set -e; rm -f $@; \

#为每个依赖文件“$<”，也就是[.c]文件生成依赖文件，“$@”表示模式“ %.d” 文件，“$$$$”意为一个随机编号
$(CC) -M $(CPPFLAGS) $< > $@.$$$$; \

#使用 sed 命令做了一个替换
sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \

#删除临时文件
rm -f $@.$$$$

总结：这个模式要做的事就是在编译器生成的依赖关系中加入[.d]文件的依赖，即把依赖关系：

main.o : main.c defs.h
转成：
main.o main.d : main.c defs.h

使用 Makefile 的“include”命令，来引入别的 Makefile 文件

#.c=.d”的意思是做一个替换，把变量$(sources)所有[.c]的字串都替换成[.d]
sources = foo.c bar.c
include $(sources:.c=.d)

include 是按次来载入文件，最先载入的[.d]文件中的目标会成为默认目标。

六 书写命令

每条规则中的命令和操作系统 Shell 的命令行是一致的。make 会一按顺序一条一条的执行命令，每条命令的开头必须以[Tab]键开头，除非，命令是紧跟在依赖规则后面的分号后的。在命令行之间中的空格或是空行会被忽略，但是如果该空格或空行是以 Tab 键开头的，那么 make 会认为其是一个空命令。

6.1 显示命令

#用“@”字符在命令行前，那么，这个命令将不被 make 显示出来
$>@echo 正在编译 XXX 模块......
正在编译 XXX 模块.....

#如果没有“@”，那么，make 将输出
$>echo 正在编译 XXX 模块......
echo 正在编译 XXX 模块......
正在编译 XXX 模块.....

如果 make 执行时，带入 make 参数“-n”或“–just-print”，那么其只是显示命令，但不会执行命令，这个功能很有利于我们调试我们的 Makefile，看看我们书写的命令是执行起来是什么样子的或是什么顺序的。

#是显示命令，但不会执行命令
make -n
make --just-print

而 make 参数“-s”或“–slient”则是全面禁止命令的显示。

#全面禁止命令
make -s
make --slient

6.2 命令执行

当依赖目标新于目标时，也就是当规则的目标需要被更新时，make 会一条一条的执行其后的命令。 如果你要让上一条命令的结果应用在下一条命令时，你应该使用分号分隔这两条命令。

cd /home/hchen; pwd  

6.3 命令出错

每当命令运行完后，make 会检测每个命令的返回码，如果命令返回成功，那么 make 会执行下一条命令，当规则中所有的命令成功返回后，这个规则就算是成功完成了。如果一个规则中的某个命令出错了（命令退出码非零），那么 make 就会终止执行当前规则，这将有可能终止所有规则的执行。

为了做忽略命令的出错，我们可以在 Makefile 的命令行前加一个减号“-”（在 Tab 键之后），标记为不管命令出不出错都认为是成功的。如：

clean:
	-rm -f *.o  

还有一个全局的办法是，给 make 加上“-i”或是“ --ignore-errors”参数，那么，Makefile 中所有命令都会忽略错误。而如果一个规则是以“.IGNORE”作为目标的，那么这个规则中的所有命令将会忽略错误。

make -i
make --ignore-errors

#如果某规则中的命令出错了，那么就终止该规则的执行，但继续执行其它规则。
make -k
make --keep-going

6.4 嵌套执行make

在一些大的工程中，我们会把我们不同模块或是不同功能的源文件放在不同的目录中，我们可以在每个目录中都书写一个该目录的 Makefile，这有利于让我们的 Makefile 变得更加地简洁，而不至于把所有的东西全部写在一个 Makefile 中，这样会很难维护我们的Makefile，这个技术对于我们模块编译和分段编译有着非常大的好处。

总控 Makefile 的变量可以传递到下级的 Makefile 中（如果你进行了显示声明），但是不会覆盖下层的 Makefile 中所定义的变量，除非指定了“-e”参数。

如果你要传递变量到下级 Makefile 中，那么你可以使用这样的声明：

export <variable ...>

如果你不想让某些变量传递到下级 Makefile 中，那么你可以这样声明：

unexport <variable ...>  

例：以下4种方式等价

#方式1
export variable = value

#方式2
variable = value
export variable

#方式3
export variable := value

#方式4
variable := value
export variable

例：以下2种方式等价

#方式1
export variable += value  

#方式2
variable += value
export variable

如果你要传递所有的变量，那么，只要一个 export 就行了。后面什么也不用跟，表示传递所有的变量。

需要注意的是，有两个变量，一个是 SHELL，一个是 MAKEFLAGS，这两个变量不管你是否 export，其总是要传递到下层 Makefile 中，特别是 MAKEFILES 变量，其中包含了 make的参数信息，如果我们执行“总控 Makefile”时有 make 参数或是在上层 Makefile 中定义了这个变量，那么 MAKEFILES 变量将会是这些参数，并会传递到下层 Makefile 中，这是一个系统级的环境变量。

但是 make 命令中的有几个参数并不往下传递，它们是“-C”,“-f”,“-h”“-o”和“-W”

还有一个在“嵌套执行”中比较有用的参数

#在make 的过程中输出一些信息，让你看到目前的工作目录。
make -w
make --print-directory

当你使用“-C”参数来指定 make 下层 Makefile 时，“-w”会被自动打开的。如果参数中有“-s”（“–slient”） 或是“–no-print-directory”，那么，“-w”总是失效的。

6.5 定义命令包

如果 Makefile 中出现一些相同命令序列，那么我们可以为这些相同的命令序列定义一个变量。定义这种命令序列的语法以“define”开始，以“endef”结束，如：

#这里“ run-yacc”是这个命令包的名字，注意其不要和 Makefile 中的变量重名
define run-yacc

#在“define”和“endef”中的两行就是命令序列
#运行Yacc程序，因为Yacc程序总是生成“y.tab.c”的文件
yacc $(firstword $^)
#更改文件名字
mv y.tab.c $@

endef


#示例
foo.c : foo.y
$(run-yacc)

#可以看出，要使用者命令包，就好像使用变量一样。命令包中“run-yacc”中的“$^”就是“foo.y”，“$@”就是“foo.c”，make在执行命令包时，命令包中的每个命令会被依次独立执行。

拓展

$@ 表示目标文件
$^ 表示所有的依赖文件
$< 表示第一个依赖文件
$? 表示比目标还要新的依赖文件列表

七 使用变量

Makefile 中的定义的变量，就像是 C/C++语言中的宏一样，他代表了一个文本字串，在 Makefile 中执行的时候其会自动原模原样地展开在所使用的地方。其与 C/C++所不同的是，你可以在 Makefile 中改变其值。在 Makefile 中，变量可以使用在“目标”，“依赖目标”，“命令”或是 Makefile 的其它部分中 。

变量的命名字可以包含字符、数字，下划线（可以是数字开头），但不应该含有“:”、 “#”、 “=”或是空字符（空格、回车等）。变量是大小写敏感的， “foo”、 “Foo”和“FOO”是三个不同的变量名。传统的 Makefile 的变量名是全大写的命名方式，但推荐使用大小写搭配的变量名，如：MakeFlags。这样可以避免和系统的变量冲突，而发生意外的事情。

7.1 变量赋值

Makefile 的变量的四种基本赋值方式：

简单赋值 ( := ) 编程语言中常规理解的赋值方式，只对当前语句的变量有效。
递归赋值 ( = ) 赋值语句可能影响多个变量，所有目标变量相关的其他变量都受影响。
条件赋值 ( ?= ) 如果变量未定义，则使用符号中的值定义变量。如果该变量已经赋值，则该赋值语句无效。
追加赋值 ( += ) 原变量用空格隔开的方式追加一个新值。

Makefile 文件中定义变量的基本语法如下：

变量的名称=值列表

Makefile 中的变量的使用其实非常的简单，因为它并没有像其它语言那样定义变量的时候需要使用数据类型。变量的名称可以由大小写字母、阿拉伯数字和下划线构成。等号左右的空白符没有明确的要求，因为在执行 make 的时候多余的空白符会被自动的删除。至于值列表，既可以是零项，又可以是一项或者是多项。如：

SUBDIRS := arch lib service driver soc app/$(APP)

#其中，arch、lib、service、、driver、soc、soc、app是顶层目录下的同级目录文件夹

调用变量的时候可以用 “$(VALU{E}_{L}IST)"或者是"${VALUE_LIST}” 来替换，这就是变量的引用。实例：

OBJ=main.o test.o test1.o test2.o
test:$(OBJ)
      gcc -o test $(OBJ)

这就是引用变量后的 Makefile 的编写，比我们之前的编写方式要简单的多。当要添加或者是删除某个依赖文件的时候，我们只需要改变变量 “OBJ” 的值就可以了。

7.2 特殊变量

$@ : 目标文件
$< : 第一个依赖
$^ : 所有的依赖

7.3 export的用法

在实际的项目中，总不会是只有一个 Makefile 文件，我们会在 Makefile 中调用另外的 Makefile 文件，呈现出 Makefile 的层级结构。

上层 make 过程要将所执行的 Makefile 中的变量传递给子 make 过程，需要明确地指出。

在 GNU make 中，实现此功能的指示符是 export。当一个变量使用 export 进行声明后，变量和它的值将被加入到当前工作的环境变量中，以后在 make 执行的所有规则的命令都可以使用这个变量。

1、在（parent，上层的）makefile中export出来变量，子makefile（sub make）中，是可以访问的。

2、而同一级别的makefile（可通过makefile中内置变量MAKELEVEL查看得知当前makefile的levlel），是无法通过export来传递变量的，即一个makefile中export出来一个变量，同一级的另外一个makefile中，是无法访问/得到的。

3、makefile中的export是导出变量到子makfile，而目标对应执行的动作中的export，是属于shell中的export，其作用是导出变量到当前shell。此两个export的作用是不同的。

7.4 include的用法

Makefile的include类似C的#include预处理指令，会将被include的文件内容原封不动的追加到当前文件。

当 make 读取到 “include” 关键字的时候，会暂停读取当前的 Makefile，而是去读 “include” 包含的文件，读取结束后再继读取当前的 Makefile 文件。“include” 使用的具体方式如下：

include <filenames>

其中，filenames 是 shell 支持的文件名（可以使用通配符表示的文件）。

注意：“include” 关键字所在的行首可以包含一个或者是多个的空格（读取的时候空格会被自动的忽略），但是不能使用 Tab 开始，否则会把 “include” 当作式命令来处理。包含的多个文件之间要使用空格分隔开。使用 “include” 包含进来的 Makefile 文件中，如果存在函数或者是变量的引用，它们会在包含的 Makefile 中展开。

include 通常使用在以下的场合：

• 在一个工程文件中，每一个模块都有一个独立的 Makefile 来描述它的重建规则。它们需要定义一组通用的变量定义或者是模式规则。通用的做法是将这些共同使用的变量或者模式规则定义在一个文件中，需要的时候用 “include” 包含这个文件。
• 当根据源文件自动产生依赖文件时，我们可以将自动产生的依赖关系保存在另一个文件中。然后在 Makefile 中包含这个文件。

注意：如果使用 “include” 包含文件的时候，指定的文件不是文件的绝对路径或者是为当前文件下没有这个文件，make 会根据文件名会在以下几个路径中去找：

首先我们在执行 make 命令的时候可以加入选项 “-I” 或 “–include-dir” 后面添加上指定的路径，如果文件存在就会被使用

如果文件不存在将会在其他的几个路径中搜索：“usr/gnu/include”、“usr/local/include” 和 “usr/include”。

如果在上面的路径没有找到 “include” 指定的文件，make 将会提示一个文件没有找到的警示提示，但是不会退出，而是继续执行 Makefile 的后续的内容。当完成读取整个 Makefile 后，make 将试图使用规则来创建通过 “include” 指定但不存在的文件。当不能创建的时候，文件将会保存退出。

使用时，通常用 “-include” 来代替 “include” 来忽略文件不存在或者是无法创建的错误提示，使用格式如下：

-include <filename>

使用方法和 “include” 的使用方法相同。

这两种方式之间的区别：

• 使用 “include ” ，make 在处理程序的时候，文件列表中的任意一个文件不存在的时候或者是没有规则去创建这个文件的时候，make 程序将会提示错误并保存退出。
• 使用 “-include ”，当包含的文件不存在或者是没有规则去创建它的时候，make 将会继续执行程序，只有真正由于不能完成终极目标重建的时候我们的程序才会提示错误保存退出。

7.5 链接脚本

在通过gcc/g++间接调用链接程序ld时，所有的ld选项前必须加上“-Wl,”,因为-Map是ld的选项。

所以，要让g++生成mapfile，需要增加编译参数“ -Wl,-Map,mapfile”。

7.6 ‘@’ ‘KaTeX parse error: Double superscript at position 3: ' '̲$’ ‘-’ '-n ’ 使用小结

7.6.1 ‘@’ 符号的使用

通常makefile会将其执行的命令行在执行前输出到屏幕上。如果将‘@’添加到命令行前，这个命令将不被make回显出来。

例：

#有@，屏幕输出  --compiling module----
@echo  --compiling module----;  

#没有@ 屏幕输出echo  --compiling module---- 
echo  --compiling module----; 

7.6.2 ’ - ’ 符号的使用

通常删除，创建文件如果碰到文件不存在或者已经创建，那么希望忽略掉这个错误，继续执行，就可以在命令前面添加 -，

例：

-rm dir；
-mkdir aaadir；

7.6.3 **’ $ '**符号的使用

美元符号$，主要扩展打开makefile中定义的变量

7.6.4 ’ $$ ’ 符号的使用

$$ 符号主要扩展打开makefile中定义的shell变量

如果make执行时，带入make参数“-n”或“–just-print”，那么其只是显示命令，但不会执行命令，这个功能很有利于我们调试我们的Makefile，看看我们书写的命令是执行起来是什么样子的或是什么顺序的。

而make参数“-s”或“–slient”则是全面禁止命令的显示。

补充说明自动化变量：

$@表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，"$@“就是匹配于目标中模式定义的集合。
% 仅当目标是函数库文件中，表示规则中的目标成员名。例如，如果一个目标是"foo.a(bar.o)"，那么，" %“就是"bar.o”，”$@“就是"foo.a”。如果目标不是函数库文件（Unix下是[.a]，Windows下是[.lib]），那么，其值为空。
$<依赖目标中的第一个目标名字。如果依赖目标是以模式（即"$<"将是符合模式的一系列的文件集。注意，其是一个一个取出来的。
$? 所有比目标新的依赖目标的集合。以空格分隔。
$^ 所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。

7.7 变量的定义

变量在声明时需要给予初值，而在使用时，需要给在变量名前加上“$”符号，但最好用小括号“（）”或是大括号“”把变量给包括起来，可以更加安全的使用这个变量。如果你要使用真实的“$”字符，那么你需要用“$$”来表示 。

变量会在使用它的地方精确的展开，就像C/C++中的宏一样，例如：

#变量的使用
foo = c
prog.o : prog.$(foo)
$(foo)$(foo) -$(foo) prog.$(foo)

#展开后得到
foo = c
prog.o : prog.c
cc -c prog.c

7.8 变量中的变量

在定义变量的值时，我们可以使用其它变量来构造变量的值，在 Makefile 中有两种方式来在用变量定义变量的值。

7.8.1 用变量定义变量的值第一种方式

使用“=”号，在“=”左侧是变量，右侧是变量的值，右侧变量的值可以定义在文件的任何一处，也就是说，右侧中的变量不一定非要是已定义好的值，其也可以使用后面定义的值。如：

#执行“make all”将会打出变量$(foo)的值是“Huh?”
foo = $(bar)
bar = $(ugh)
ugh = Huh?
all:
	echo $(foo)

但这种形式也有不好的地方，那就是递归定义，这会让 make 陷入无限的变量展开过程中去，如：

CFLAGS = $(CFLAGS) -O
或：
A = $(B)
B = $(A)

还有就是如果在变量中使用函数，那么，这种方式会让我们的 make 运行时非常慢，更糟糕的是，他会使得两个 make 的函数“wildcard”和“shell”发生不可预知的错误。因为你不会知道这两个函数会被调用多少次。

7.8.2 用变量定义变量的值第二种方式

为了避免上面的这种方法，我们可以使用 make 中的另一种用变量来定义变量的方法。这种方法使用的是“:=”操作符，如：

x := foo
y := $(x) bar
x := later
#其等价于：
y := foo bar
x := later

值得一提的是，这种方法，前面的变量不能使用后面的变量，只能使用前面已定义好了的变量。

例子，其中包括了 make的函数、条件表达式和一个系统变量“MAKELEVEL”的使用：

对于系统变量“MAKELEVEL”，其意思是，如果我们的 make 有一个嵌套执行的动作，那么，这个变量会记录了我们的当前 Makefile 的调用层数。

ifeq (0,${MAKELEVEL})
cur-dir := $(shell pwd)
whoami := $(shell whoami)
host-type := $(shell arch)
MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
endif

如果我们要定义一个变量，其值是一个空格，那么我们可以这样来：

#nullstring 是一个 Empty 变量，其中什么也没有
nullstring :=
#而我们的 space 的值是一个空格，因为操作符的右边是很难描述一个空格的，
#先用一个 Empty 变量来标明变量的值开始了，而后面采用“#”注释符来表示变量定义的终止，这样，我们可以定义出其值是一个空格的变量
space := $(nullstring) # end of the line

7.9 变量高级用法

7.9.1 变量值的替换

我们可以替换变量中的共有的部分，其格式是

$(var:a=b)

或是

${var:a=b}

其意思是，把变量“var”中所有以“a“字串”结尾“的”a“替换成”b“字串。这里”结尾“的意思是”空格“或是”结束符“。

示例：

#定义一个$(foo)变量
foo := a.o b.o c.o
#把$(foo)中所有以.o字串结尾全部替换成.c
#所有$(bar)的值就是：a.c b.c c.c
bar := $(foo:.o=.c)

7.9.2 以静态模式定义的变量替换

这依赖于被替换字串中的有相同的模式，模式中必须包含一个“%”字符

示例：

foo := a.o b.o c.o
#把$(foo)中所有以.o字串结尾全部替换成.c
#所有$(bar)的值就是：a.c b.c c.c
bar := $(foo:%.o=%.c)

7.9.3 把变量的值再当成变量

示例：

x = y
y = z
a := $($(x))

在这个例子中，$(x)的值是“y”，所以$($(x))就是$(y)，于是$(a)的值就是“z”。（注意，是“x=y”，而不是“x=$(y)”。

再复杂一点，我们再加上函数：

x = variable1
variable2 := Hello
y = $(subst 1,2,$(x))
z = y
a := $($($(z)))

这 个 例 子 中 ， “$($($(z)))”扩展为“$($(y))”，而其再次被扩展为“$($(subst1,2,$(x)))”。$(x)的值是“variable1”，subst函数把“variable1”中的所有“1”字串替换成“2”字串，于是，“variable1”变成“variable2”，再取其值，所以，最终，$(a)的值就是$(variable2)的值——“Hello”。

“把变量的值再当成变量”这种技术，同样可以用在操作符的左边：

dir = foo
$(dir)_sources := $(wildcard $(dir)/*.c)
define $(dir)_print
lpr $($(dir)_sources)
endef

这个例子中定义了三个变量：“dir”，“foo_sources” 和“foo_print”。

7.10 追加变量值

我们可以使用“+=”操作符给变量追加值，如：

objects = main.o foo.o bar.o utils.o
objects += another.o

于是，$(objects)值变成：“main.o foo.o bar.o utils.o another.o”（another.o被追加进去了）

如果变量之前没有定义过，那么， “+=”会自动变成“=”， 如果前面有变量定义， 那么“+=”会继承于前次操作的赋值符。如果前一次的是“:=”， 那么“+=”会以“:=”作为其赋值符，如

variable := value
variable += more

等价于

variable := value
variable := $(variable) more  

如果是

variable = value
variable += more

由于前次的赋值符是“=”，所以“+=”也会以“=”来做为赋值，make 会自动为我们解决这个问题，不会发生变量的递补归定义。

7.11 override 指示符

语法：

override <variable> = <value>
override <variable> := <value>

也可以追加：

override <variable> += <more text>

对于多行的变量定义，我们用 define 指示符， 在 define 指示符前， 也同样可以使用 ovveride
指示符，如：

override define foo
bar
endef

7.12 多行变量

还有一种设置变量值的方法是使用 define 关键字。 使用 define 关键字设置变量的值可以有换行，这有利于定义一系列的命令。

define 指示符后面跟的是变量的名字，而重起一行定义变量的值，定义是以 endef 关键字结束。其工作方式和“=”操作符一样。变量的值可以包含函数、命令、文字，或是其它变量。 因为命令需要以[Tab]键开头， 所以如果你用 define 定义的命令变量中没有以[Tab]键开头，那么 make 就不会把其认为是命令。

用法：

define two-lines
echo foo
echo $(bar)
endef

7.13 环境变量

make 运行时的系统环境变量可以在 make 开始运行时被载入到 Makefile 文件中，但是如果 Makefile 中已定义了这个变量，或是这个变量由 make 命令行带入，那么系统的环境变量的值将被覆盖。（如果 make 指定了“-e”参数，那么，系统环境变量将覆盖 Makefile 中定义的变量）

因此，如果我们在环境变量中设置了“CFLAGS”环境变量，那么我们就可以在所有的Makefile 中使用这个变量了。这对于我们使用统一的编译参数有比较大的好处。如果Makefile 中定义了CFLAGS，那么则会使用 Makefile 中的这个变量，如果没有定义则使用系统环境变量的值，一个共性和个性的统一，很像“全局变量”和“局部变量”的特性。

当 make 嵌套调用时，上层 Makefile 中定义的变量会以系统环境变量的方式传递到下层的 Makefile 中。 默认情况下，只有通过命令行设置的变量会被传递。而定义在文件中的变量，如果要向下层 Makefile 传递，则需要使用exprot 关键字来声明。

7.14 目标变量

“$<”等这种类量的自动化变量就属于“规则型变量”，这种变量的值依赖于规则的目标和依赖目标的定义。

我们可以为某个目标设置局部变量，这种变量被称为“Target-specific Variable”，它可以和“全局变
量”同名，因为它的作用范围只在这条规则以及连带规则中，所以其值也只在作用范围内有效。而不会影响规则链以外的全局变量的值。

其语法是：

<target ...> : <variable-assignment>
<target ...> : overide <variable-assignment>

可以是前面讲过的各种赋值表达式，如“=”、“:=”、“+=”或是“？=”。

第二个语法是针对于 make 命令行带入的变量，或是系统环境变量。这个特性非常的有用，当我们设置了这样一个变量，这个变量会作用到由这个目标所引发的所有的规则中去。如：

prog : CFLAGS = -g
prog : prog.o foo.o bar.o
$(CC) $(CFLAGS) prog.o foo.o bar.o
prog.o : prog.c
$(CC) $(CFLAGS) prog.c

foo.o : foo.c
$(CC) $(CFLAGS) foo.c
bar.o : bar.c
$(CC) $(CFLAGS) bar.c

在这个示例中，不管全局的$(CFLAGS)的值是什么，在prog目标，以及其所引发的所有规则中（prog.ofoo.obar.o的规则），$(CFLAGS)的值都是“-g”

7.15 模式变量

在 GNU 的 make 中，还支持模式变量（Pattern-specific Variable），通过上面的目标变量中，我们知道，变量可以定义在某个目标上。模式变量的好处就是，我们可以给定一种“模式”，可以把变量定义在符合这种模式的所有目标上。

make 的“模式”一般是至少含有一个“%”的，所以，我们可以以如下方式给所有以[.o]结尾的目标定义目标变量：

%.o : CFLAGS = -O

语法：

<pattern ...> : <variable-assignment>
<pattern ...> : override <variable-assignment>

override 同样是针对于系统环境传入的变量，或是 make 命令行指定的变量。

八 使用条件判断

使用条件判断，可以让 make 根据运行时的不同情况选择不同的执行分支。条件表达式可以是比较变量的值，或是比较变量和常量的值。

日常使用 Makefile 编译文件时，可能会遇到需要分条件执行的情况，比如在一个工程文件中，可编译的源文件很多，但是它们的类型是不相同的，所以编译文件使用的编译器也是不同的。手动编译去操作文件显然是不可行的（每个文件编译时需要注意的事项很多），所以 make 为我们提供了条件判断来解决这样的问题。

条件语句的作用：条件语句可以根据一个变量的值来控制 make 执行或者时忽略 Makefile 的特定部分，条件语句可以是两个不同的变量或者是常量和变量之间的比较。

注意：条件语句只能用于控制 make 实际执行的 Makefile 文件部分，不能控制规则的 shell 命令执行的过程。

8.1 条件表达式的语法

<conditional-directive>
<text-if-true>
endif

#以及

<conditional-directive>
<text-if-true>
else
<text-if-false>
endif

其中表示条件关键字，如“ifeq”。这个关键字有四个。

8.2 条件判断中使用到的一些关键字

关键字	功能
ifeq	判断参数是否不相等，相等为 true，不相等为 false。
ifneq	判断参数是否不相等，不相等为 true，相等为 false。
ifdef	判断是否有值，有值为 true，没有值为 false。
ifndef	判断是否有值，没有值为 true，有值为 false。
else	判断条件不满足时执行的部分，不是所有条件语句都需要此部分
endif	表示一个条件语句的结束，任何一个条件表达式都必须以“endif”结束

8.3 ifeq 和 ifneq

条件判断的使用方式如下：

#比较参数“arg1”和“arg2”的值是否相同，如果相同，则为真。
ifeq (ARG1, ARG2)
ifeq 'ARG1' 'ARG2'
ifeq "ARG1" "ARG2"
ifeq "ARG1" 'ARG2'
ifeq 'ARG1' "ARG2"

#比较参数“arg1”和“arg2”的值是否不同，如果不同，则为真。
ifneq (ARG1, ARG2)
ifneq 'ARG1' 'ARG2'
ifneq "ARG1" "ARG2"
ifneq "ARG1" 'ARG2'
ifneq 'ARG1' "ARG2"

8.4 ifdef 和 ifndef

使用方式如下：

ifdef VARIABLE-NAME

关键字“ifdef”用来判断一个变量是否已经定义。

ifdef 只是测试一个变量是否有值，
不会对变量进行替换展开来判断变量的值是否为空。
对于变量“VARIABLE-NAME” ，除了
“VARIABLE-NAME=”这种情况以外，使用其它方式对它的定义都会使“ifdef”返回真。
就是说，即使我们通过其它方式（比如，定义它的值引用了其它的变量）给它赋了一个空值， “ifdef”也会返回真。

当我们需要判断一个变量的值是否为空的时候需要使用“ifeq" 而不是“ifdef”。

注意：在 make 读取 Makefile 文件时计算表达式的值，并根据表达式的值决定判断语句中的哪一个部分作为此 Makefile 所要执行的内容。因此在条件表达式中不能使用自动化变量，自动化变量在规则命令执行时才有效，更不能将一个完整的条件判断语句分卸在两个不同的 Makefile 的文件中。在一个 Makefile 中使用指示符 “include” 包含另一个 Makefile 文件。

8.5 示例：

#判断$(CC)变量是否“gcc”，如果是的话，则使用 GNU 函数编译目标
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

ifeq、else 和 endif。ifeq 的意思表示条件语句的开始，并指定一个条件表达式，表达式包含两个参数，以逗号分隔，表达式以圆括号括起。else 表示条件表达式为假的情况。endif 表示一个条件语句的结束，任何一个条件表达式都应该以 endif 结束。

上面的那个例子写得更简洁一些：

ibs_for_gcc = -lgnu
normal_libs =
ifeq ($(CC),gcc)
libs=$(libs_for_gcc)
else
libs=$(normal_libs)
endif
foo: $(objects)
$(CC) -o foo $(objects) $(libs)

特别注意的是，make 是在读取 Makefile 时就计算条件表达式的值，并根据条件表达式的值来选择语句，所以，你最好不要把自动化变量（如“$@”等）放入条件表达式中，因为自动化变量是在运行时才有的。

而且，为了避免混乱，make 不允许把整个条件语句分成两部分放在不同的文件中。

九 使用函数

在 Makefile 中可以使用函数来处理变量，从而让我们的命令或是规则更为的灵活和具有智能。

函数调用后，函数的返回值可以当做变量来使用。

9.1 函数调用的语法

函数调用，很像变量的使用，也是以“$”来标识的，其语法如下：

$(<function> <arguments>)

或是

${<function> <arguments>}

这里，就是函数名，make 支持的函数不多。是函数的参数，参数间以逗号“,”分隔，而函数名和参数之间以“空格”分隔。函数调用以“$”开头，以圆括号或花括号把函数名和参数括起。

示例：

#$(comma)的值是一个逗号
comma:= ,
#定义了一个空格
empty:=
#$(space)使用了$(empty)定义了一个空格
space:= $(empty) $(empty)
#$(foo)的值是“a b c”
foo:= a b c
#$(bar)的定义，调用了函数“subst”，这是一个替换函数，这个函数有三个参数，
#第一个参数是被替换字串，第二个参数是替换字串，第三个参数是替换操作作用的字串。
#这个函数也就是把$(foo)中的空格替换成逗号，所以$(bar)的值是“a,b,c”。
bar:= $(subst $(space),$(comma),$(foo))

9.2 字符串处理函数

9.2.1 subst

语法：

$(subst <from>,<to>,<text>)

名称：字符串替换函数——subst。
功能：把字串 中的字符串替换成。
返回：函数返回被替换过后的字符串。

示例：

#把“feet on the street”中的“ee”替换成“EE”，返回结果是“fEEt on thestrEEt”
$(subst ee,EE,feet on the street)

9.2.2 patsubst

语法：

$(patsubst <pattern>,<replacement>,<text>)

名称：模式字符串替换函数——patsubst。
功能：查找 中的单词（单词以“空格”、“Tab”或“回车”“换行”分隔）是否符合模式，如果匹配的话，则以替换。这里，可以包括通配符“%”， 表示任意长度的字串。 如果中也包含“%”， 那么， 中的这个“%”将是中的那个“%”所代表的字串。（可以用“\”来转义， 以“%”来表示真实含义的“%”字符）
返回：函数返回被替换过后的字符串。

示例：

#把字串“x.c.c bar.c”符合模式[%.c]的单词替换成[%.o]，返回结果是“x.c.o bar.o”
$(patsubst %.c,%.o,x.c.c bar.c)  

9.2.3 strip

语法：

$(strip <string>)

名称：去空格函数——strip。
功能：去掉字串中开头和结尾的空字符。
返回：返回被去掉空格的字符串值。

示例：

#把字串“a b c ”去到开头和结尾的空格，结果是“a b c”
$(strip a b c )

9.2.4 findstring

语法：

$(findstring <find>,<in>)

$(findstring ,)
名称：查找字符串函数——findstring。
功能：在字串中查找字串。
返回：如果找到，那么返回，否则返回空字符串。
示例：

#第一个函数返回“a”字符串，第二个返回“”字符串（空字符串）  
$(findstring a,a b c)
$(findstring a,b c)

9.2.5 filter

语法：

$(filter <pattern...>,<text>)

名称：过滤函数——filter。
功能：以模式过滤 字符串中的单词，保留符合模式的单词。可以有多个模式。
返回：返回符合模式的字串。
示例：

#$(filter %.c %.s,$(sources))返回的值是“foo.c bar.c baz.s”
sources := foo.c bar.c baz.s ugh.h
foo: $(sources)
cc $(filter %.c %.s,$(sources)) -o foo

9.2.6 filter-out

语法：

$(filter-out <pattern...>,<text>)

名称：反过滤函数——filter-out。
功能：以模式过滤 字符串中的单词，去除符合模式的单词。可以有多个模式。
返回：返回不符合模式的字串。
示例：

#$(filter-out $(mains),$(objects)) 返回值是“foo.o bar.o”
objects=main1.o foo.o main2.o bar.o
mains=main1.o main2.o
$(filter-out $(mains),$(objects)) 

9.2.7 sort

语法：

$(sort <list>)

名称：排序函数——sort。
功能：给字符串中的单词排序（升序）。
返回：返回排序后的字符串。
示例：

#返回“bar foo lose” 
$(sort foo bar lose)

备注：sort 函数会去掉中相同的单词

9.2.8 word

语法：

$(word <n>,<text>)

名称：取单词函数——word。
功能：取字符串 中第个单词。 （从一开始）
返回：返回字符串 中第个单词。如果比 中的单词数要大，那么返回空字符串。
示例：

#返回值是“bar”
$(word 2, foo bar baz)

9.2.9 wordlist

语法：

$(wordlist <s>,<e>,<text>)

名称：取单词串函数——wordlist。
功能：从字符串< text >中取从< s >开始到< e >的单词串。< s >和< e >是一个数字。
返回：返回字符串< text >中从< s >到< e >的单词字串。如果< s >比< text >中的单词数要大，那么返回空字符串。如果< e >大于< text >的单词数，那么返回从< s >开始，到< text >结束的单词串。

示例：

#返回值是“bar baz”
$(wordlist 2, 3, foo bar baz)

9.2.10 words

语法：

$(words <text>)

名称：单词个数统计函数——words。
功能：统计 中字符串中的单词个数。
返回：返回 中的单词数。
示例：

#返回值是“3”
$(words, foo bar baz)

备注：如果我们要取 中最后的一个单词，我们可以这样：$(word $(words ), )

9.2.11 firstword

语法：

$(firstword <text>)

名称：首单词函数——firstword。
功能：取字符串 中的第一个单词。
返回：返回字符串 的第一个单词。
示例：

#返回值是“foo”
$(firstword foo bar)

备注：这个函数可以用 word 函数来实现：$(word 1, )。

9.2.12 字符串函数实例

以上，是所有的字符串操作函数，如果搭配混合使用，可以完成比较复杂的功能。这里，举一个现实中应用的例子。我们知道，make 使用“VPATH”变量来指定“依赖文件”的搜索路径。于是，我们可以利用这个搜索路径来指定编译器对头文件的搜索路径参数 CFLAGS，如：

override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))

如 果 我 们 的 “$(VPATH)”值是“src:../headers”，那么“$(patsubst%,-I%,$(subst:,,$(VPATH)))”将返回“-Isrc -I…/headers”，这正是 cc 或 gcc 搜索头文件路径的参数。

9.3 文件名操作函数

主要是处理文件名的。每个函数的参数字符串都会被当做一个或是一系列的文件名来对待。

9.3.1 dir

语法：

$(dir <names...>)

名称：取目录函数——dir。
功能：从文件名序列中取出目录部分。目录部分是指最后一个反斜杠（“/”）之前的部分。如果没有反斜杠，那么返回“./”。
返回：返回文件名序列的目录部分。
示例：

#返回值是“src/ ./”
$(dir src/foo.c hacks)

9.3.2 notdir

语法：

$(notdir <names...>)

名称：取文件函数——notdir。
功能：从文件名序列中取出非目录部分。非目录部分是指最后一个反斜杠（“ /”）之后的部分。
返回：返回文件名序列的非目录部分。
示例：

#返回值是“foo.c hacks”
$(notdir src/foo.c hacks)

9.3.3 suffix

语法：

$(suffix <names...>)

名称：取后缀函数——suffix。
功能：从文件名序列中取出各个文件名的后缀。
返回：返回文件名序列的后缀序列，如果文件没有后缀，则返回空字串。
示例：

#返回值是“.c .c” 
$(suffix src/foo.c src-1.0/bar.c hacks)

9.3.4 basename

语法：

$(basename <names...>)

名称：取前缀函数——basename。
功能：从文件名序列中取出各个文件名的前缀部分。
返回：返回文件名序列的前缀序列，如果文件没有前缀，则返回空字串。
示例：

#返回值是“src/foo src-1.0/bar hacks”。  
$(basename src/foo.c src-1.0/bar.c hacks)

9.3.5 addsuffix

语法：

$(addsuffix <suffix>,<names...>)

名称：加后缀函数——addsuffix。
功能：把后缀加到中的每个单词后面。
返回：返回加过后缀的文件名序列。
示例：

#返回值是“foo.c bar.c”
$(addsuffix .c,foo bar)

9.3.6 addprefix

语法：

$(addprefix <prefix>,<names...>)

名称：加前缀函数——addprefix。
功能：把前缀加到中的每个单词后面。
返回：返回加过前缀的文件名序列。
示例：

#返回值是“src/foo src/bar”
$(addprefix src/,foo bar)

9.3.7 join

语法：

$(join <list1>,<list2>)

名称：连接函数——join。
功能：把中的单词对应地加到的单词后面。如果的单词个数要比的多，那么，中的多出来的单词将保持原样。如果的单词个数要比多，那么，多出来的单词将被复制到中。
返回：返回连接过后的字符串。
示例：

#返回值是“aaa111 bbb222 333”
$(join aaa bbb , 111 222 333)

9.4 foreach函数

这个函数是用来做循环用的， Makefile中的 foreach 函数几乎是仿照于 Unix 标准 Shell（ /bin/sh）中的 for 语句，或是 C-Shell
（/bin/csh）中的 foreach 语句而构建的。它的语法是：

$(foreach <var>,<list>,<text>)

这个函数的意思是，把参数中的单词逐一取出放到参数所指定的变量中，然后再执行 所包含的表达式。每一次 会返回一个字符串，循环过程中， 的所返回的每个字符串会以空格分隔，最后当整个循环结束时， 所返回的每个字符串所组成的整个字符串（以空格分隔）将会是 foreach 函数的返回值。

所以， 最好是一个变量名， 可以是一个表达式，而 中一般会使用 这个参数来依次枚举中的单词。举个例子：

names := a b c d
files := $(foreach n,$(names),$(n).o)

上面的例子中，$(name)中的单词会被挨个取出，并存到变量“n”中，“$(n).o”每次根据“$(n)”计算出一个值，这些值以空格分隔，最后作为foreach函数的返回，所以，$(files)的值是“a.o b.o c.o d.o”。

**注意，foreach 中的参数是一个临时的局部变量，foreach 函数执行完后，参数的变量将不在作用，其作用域只在 foreach 函数当中。 **

9.5 if函数

if 函数很像 GNU 的 make 所支持的条件语句——ifeq，if 函数的语法是：

$(if <condition>,<then-part>)

或是

$(if <condition>,<then-part>,<else-part>)

可见，if 函数可以包含“else”部分，或是不含。即 if 函数的参数可以是两个，也可以是三个。参数是 if 的表达式，如果其返回的为非空字符串，那么这个表达式就相当于返回真，于是，会被计算，否则会被计算。

而 if 函数的返回值是，如果为真（非空字符串），那个会是整个函数的返回值，如果为假（空字符串），那么会是整个函数的返回值，此时如果没有被定义，那么，整个函数返回空字串。

9.6 call函数

call 函数是唯一一个可以用来创建新的参数化的函数。你可以写一个非常复杂的表达式，这个表达式中，你可以定义许多参数，然后你可以用 call 函数来向这个表达式传递参数。其语法是：

当 make 执行这个函数时，参数中的变量，如$(1)，$(2)，$(3)等，会被参数，，依次取代。而的返回值就是 call 函数的返回值。例如：

reverse = $(1) $(2)
foo = $(call reverse,a,b)

foo 的值就是“a b”。当然，参数的次序是可以自定义的，不一定是顺序的，如：

reverse = $(2) $(1)
foo = $(call reverse,a,b)

此时的 foo 的值就是“b a”

9.7 origin函数

origin 函数不像其它的函数，他并不操作变量的值，他只是告诉你你的这个变量是哪里来的？其语法是：

$(origin <variable>)

注意，是变量的名字，不应该是引用。所以最好不要在中使用“$”字符。Origin 函数会以其返回值来告诉你这个变量的“出生情况”，下面，是 origin函数的返回值:

undefined	#如果<variable>从来没有定义过，origin 函数返回这个值“undefined”。
default		#如果<variable>是一个默认的定义，比如“CC”这个变量，这种变量我们将在后面讲述。 
			#environment” 如果<variable>是一个环境变量， 并且当 Makefile 被执行时， “-e”参数没有被打开。
file		#如果<variable>这个变量被定义在 Makefile 中。		
			
command line	#如果<variable>这个变量是被命令行定义的	
override		#如果<variable>是被 override 指示符重新定义的	
automatic		#如果<variable>是一个命令运行中的自动化变量

示例：

#在 Make.def 中定义了一个变量“bletch”，而我们的环境中也有一个环境变量“bletch”，此时，我们想判断一下，如果变量来源于环境，那么我们就把之重定义了，如果来源于 Make.def 或是命令行等非环境的，那么我们就不重新定义它。
ifdef bletch
ifeq "$(origin bletch)" "environment"
bletch = barf, gag, etc.
endif
endif

我们用 override 是可以达到这样的效果，可是 override 过于粗暴，它同时会把从命令行定义的变量也覆盖了，而我们只想重新定义环境传来的，而不想重新定义命令行传来的。

9.8 shell函数

shell 函数也不像其它的函数。顾名思义，它的参数应该就是操作系统 Shell 的命令。它和反引号“`”是相同的功能。这就是说， shell 函数把执行操作系统命令后的输出作为函数返回。于是，我们可以用操作系统命令以及字符串处理命令 awk，sed 等等命令来生成一个变量，如：

contents := $(shell cat foo)
files := $(shell echo *.c)

注意，这个函数会新生成一个 Shell 程序来执行命令，所以你要注意其运行性能，如果你的Makefile 中有一些比较复杂的规则，并大量使用了这个函数，那么对于你的系统性能是有害的。特别是 Makefile 的隐晦的规则可能会让你的 shell 函数执行的次数比你想像的多得多。

9.10 控制make的函数

make 提供了一些函数来控制 make 的运行。通常，你需要检测一些运行 Makefile 时的运行时信息，并且根据这些信息来决定，你是让 make 继续执行，还是停止。

9.10.1 error函数

语法：

$(error <text ...>)

产生一个致命的错误，<text …>是错误信息。注意，error 函数不会在一被使用就会产生错误信息，所以如果你把其定义在某个变量中，并在后续的脚本中使用这个变量，那么也是可以的。例如：

#示例一会在变量 ERROR_001 定义了后执行时产生 error 调用
ifdef ERROR_001
$(error error is $(ERROR_001))
endif

#示例二则在目录 err被执行时才发生 error 调用
ERR = $(error found an error!)
.PHONY: err
err: ; $(ERR)

9.10.2 warning

语法：

$(warning <text ...>)

这个函数很像 error 函数，只是它并不会让 make 退出，只是输出一段警告信息，而 make 继续执行。

十 make的运行

一般来说，最简单的就是直接在命令行下输入 make 命令，make 命令会找当前目录的makefile 来执行，一切都是自动的。但也有时你也许只想让 make 重编译某些文件，而不是整个工程，而又有的时候你有几套编译规则，你想在不同的时候使用不同的编译规则，等等。

10.1 make的退出码

make 命令执行后有三个退出码：

0 - 表示成功执行。
1 - 如果 make 运行时出现任何错误，其返回 1。
2 - 如果你使用了 make 的“-q”选项，并且 make 使得一些目标不需要更新，那么返回 2。  

10.2 指定Makefile

GNU make 找寻默认的 Makefile 的规则是在当前目录下依次找三个文件——“GNUmakefile”、“makefile”和“Makefile”。其按顺序找这三个文件，一旦找到，就开始读取这个文件并执行。

我们也可以给 make 命令指定一个特殊名字的 Makefile。要达到这个功能，我们要使用

make -f
#或是
make --file
#或是
make --makefile

例如：

make –f hchen.mk

如果在 make 的命令行时， 你不只一次地使用了“-f”参数，那么， 所有指定的 makefile将会被连在一起传递给 make 执行。

10.3 指定目标

一般来说，make 的最终目标是 makefile 中的第一个目标，而其它目标一般是由这个目标连带出来的。这是 make 的默认行为。

一般来说，你的 makefile 中的第一个目标是由许多个目标组成，你可以指示 make，让其完成你所指定的目标。要达到这一目的很简单，需在 make 命令后直接跟目标的名字就可以完成（如前面提到的“make clean”形式）

任何在 makefile 中的目标都可以被指定成终极目标，但是除了以“-”打头，或是包含了“=”的目标，因为有这些字符的目标，会被解析成命令行参数或是变量。甚至没有被我们明确写出来的目标也可以成为 make 的终极目标，也就是说，只要 make 可以找到其隐含规则推导规则，那么这个隐含目标同样可以被指定成终极目标。

有一个 make 的环境变量叫“MAKECMDGOALS”，这个变量中会存放你所指定的终极目标的列表，如果在命令行上，你没有指定目标，那么，这个变量是空值。这个变量可以让你使用在一些比较特殊的情形下。比如下面的例子：

#只要我们输入的命令不是“make clean”，那么 makefile 会自
动包含“foo.d”和“bar.d”这两个 makefile。
sources = foo.c bar.c
ifneq ( $(MAKECMDGOALS),clean)
include $(sources:.c=.d)
endif

使用指定终极目标的方法可以很方便地让我们编译我们的程序，例如下面这个例子：

.PHONY: all
all: prog1 prog2 prog3 prog4

从这个例子中，我们可以看到， 这个 makefile 中有四个需要编译的程序——“prog1”，“prog2”， “prog3”和 “prog4”，我们可以使用“make all”命令来编译所有的目标（如果把 all 置成第一个目标，那么只需执行“make”），我们也可以使用“make prog2”来单独编译目标“prog2”。

即然 make 可以指定所有 makefile 中的目标，那么也包括“伪目标”，于是我们可以根据这种性质来让我们的 makefile 根据指定的不同的目标来完成不同的事。在 Unix 世界中，软件发布时，特别是 GNU 这种开源软件的发布时，**其 makefile 都包含了编译、安装、打包等功能。**我们可以参照这种规则来书写我们的 makefile 中的目标。

all		#这个伪目标是所有目标的目标，其功能一般是编译所有的目标。
clean	#这个伪目标功能是删除所有被 make 创建的文件。
install	#这个伪目标功能是安装已编译好的程序，其实就是把目标执行文件拷贝到指定的目标中去。
print	#这个伪目标的功能是列出改变过的源文件。
tar		#这个伪目标功能是把源程序打包备份。也就是一个 tar 文件。
dist	#这个伪目标功能是创建一个压缩文件，一般是把 tar 文件压成 Z 文件。或是 gz 文件
TAGS	#这个伪目标功能是更新所有的目标，以备完整地重编译使用
check和test	#这两个伪目标一般用来测试 makefile 的流程

10.4 检查规则

有时候，我们不想让我们的 makefile 中的规则执行起来，我们只想检查一下我们的命令，或是执行的序列。于是我们可以使用 make 命令的下述参数：

-n
--just-print
--dry-run
--recon

不执行参数，这些参数只是打印命令，不管目标是否更新，把规则和连带规则下的命令打印出来，但不执行，这些参数对于我们调试 makefile 很有用处。

-t
--touch

这个参数的意思就是把目标文件的时间更新，但不更改目标文件。也就是说，make 假装编译目标，但不是真正的编译目标，只是把目标变成已编译过的状态。

-q
--question  

这个参数的行为是找目标的意思，也就是说，如果目标存在，那么其什么也不会输出，当然也不会执行编译，如果目标不存在，其会打印出一条出错信息。

-W <file>
--what-if=<file>
--assume-new=<file>
--new-file=<file>  

这个参数需要指定一个文件。一般是是源文件（或依赖文件），Make 会根据规则推导来运行依赖于这个文件的命令，一般来说，可以和“-n”参数一同使用，来查看这个依赖文件所发生的规则命令

另外一个用法是结合“-p”和“-v”来输出 makefile 被执行时的信息 。

10.5 make的参数

下面列举了所有 GNU make 3.80 版的参数定义。 其它版本和产商的 make 大同小异，不过其它产商的 make 的具体参数还是请参考各自的产品文档。

-b
-m

这两个参数的作用是忽略和其它版本 make 的兼容性。

-B
--always-make

表明认为所有的目标都需要更新（重编译）。

-C <dir>
--directory=<dir>

指定读取 makefile 的目录。如果有多个“-C”参数，make 的解释是后面的路径以前面的作为相对路径，并以最后的目录作为被指定目录。

例如：

make –C ~hchen/test –C prog

#等价于

make –C ~hchen/test/prog

—debug[=<options>]

输出 make 的调试信息。它有几种不同的级别可供选择，如果没有参数，那就是输出最简单的调试信息。下面是的取值：

a —— 也就是 all，输出所有的调试信息。（会非常的多）
b —— 也就是 basic，只输出简单的调试信息。即输出不需要重编译的目标。
v —— 也就是 verbose，在 b 选项的级别之上。输出的信息包括哪个 makefile 被解析，不需要被重编译的依赖文件（或是依赖目标）等。
i —— 也就是 implicit，输出所以的隐含规则。
j —— 也就是 jobs，输出执行规则中命令的详细信息，如命令的 PID、返回码等。
m —— 也就是 makefile，输出 make 读取 makefile，更新 makefile，执行 makefile 的信息。

-d

相当于“–debug=a”。

-e
--environment-overrides

指明环境变量的值覆盖 makefile 中定义的变量的值。

-f=<file>
--file=<file>
--makefile=<file>

指定需要执行的 makefile。

-h
--help

显示帮助信息。

-i
--ignore-errors

在执行时忽略所有的错误

-I <dir>
--include-dir=<dir>

指定一个被包含 makefile 的搜索目标。可以使用多个“-I”参数来指定多个目录。

-j [<jobsnum>]
--jobs[=<jobsnum>]

指同时运行命令的个数。如果没有这个参数，make 运行命令时能运行多少就运行多少。如果有一个以上的“-j”参数，那么仅最后一个“-j”才是有效的。（注意这个参数在 MS-DOS中是无用的）

-k
--keep-going

出错也不停止运行。如果生成一个目标失败了，那么依赖于其上的目标就不会被执行了。

-l <load>
--load-average[=<load]
—max-load[=<load>]

指定 make 运行命令的负载。

-n
--just-print
--dry-run
--recon

仅输出执行过程中的命令序列，但并不执行。

-o <file>
--old-file=<file>
--assume-old=<file>

不重新生成的指定的，即使这个目标的依赖文件新于它。

-p
--print-data-base

输出 makefile 中的所有数据，包括所有的规则和变量。这个参数会让一个简单的 makefile都会输出一堆信息。如果你只是想输出信息而不想执行 makefile，你可以使用“make -qp”命令。如果你想查看执行 makefile 前的预设变量和规则，你可以使用“make –p –f
/dev/null”。这个参数输出的信息会包含着你的 makefile 文件的文件名和行号，所以，用这个参数来调试你的 makefile 会是很有用的，特别是当你的环境变量很复杂的时候。

-q
--question

不运行命令，也不输出。仅仅是检查所指定的目标是否需要更新。如果是 0 则说明要更新，如果是 2 则说明有错误发生。

-r
--no-builtin-rules

禁止 make 使用任何隐含规则。

-R
--no-builtin-variabes

禁止 make 使用任何作用于变量上的隐含规则。

-s
--silent
--quiet

在命令运行时不输出命令的输出。

-S
--no-keep-going
--stop

取消“-k”选项的作用。因为有些时候，make 的选项是从环境变量“MAKEFLAGS”中继承下来的。所以你可以在命令行中使用这个参数来让环境变量中的“-k”选项失效。

-t
--touch

相当于 UNIX 的 touch 命令，只是把目标的修改日期变成最新的，也就是阻止生成目标的命令运行。

-v
--version

输出 make 程序的版本、版权等关于 make 的信息。

-w
--print-directory

输出运行 makefile 之前和之后的信息。这个参数对于跟踪嵌套式调用 make 时很有用。

--no-print-directory

禁止“-w”选项。

-W <file>
--what-if=<file>
--new-file=<file>
--assume-file=<file>

假定目标需要更新，如果和“-n”选项使用，那么这个参数会输出该目标更新时的运行动作。如果没有“-n”那么就像运行 UNIX 的“touch”命令一样，使得的修改时间为当前时间。

--warn-undefined-variables

只要 make 发现有未定义的变量，那么就输出警告信息。

十一 隐含规则

在我们使用 Makefile 时，有一些我们会经常使用，而且使用频率非常高的东西，比如，我们编译 C/C++的源程序为中间目标文件（Unix 下是[.o]文件，Windows 下是[.obj]文件）。

“隐含规则”也就是一种惯例，make 会按照这种“惯例”心照不喧地来运行，那怕我们的 Makefile 中没有书写这样的规则。例如，把[.c]文件编译成[.o]文件这一规则，你根本就不用写出来，make 会自动推导出这种规则，并生成我们需要的[.o]文件。

“隐含规则”会使用一些我们系统变量，我们可以改变这些系统变量的值来定制隐含规则的运行时的参数。如系统变量“CFLAGS”可以控制编译时的编译器参数。

我们还可以通过“模式规则”的方式写下自己的隐含规则。用“后缀规则”来定义隐含规则会有许多的限制。使用“模式规则”会更回得智能和清楚，但“后缀规则”可以用来保证我们 Makefile 的兼容性。

11.1 使用隐含规则

如果要使用隐含规则生成你需要的目标，你所需要做的就是不要写出这个目标的规则。那么，make 会试图去自动推导产生这个目标的规则和命令，如果 make 可以自动推导生成这个目标的规则和命令，那么这个行为就是隐含规则的自动推导。

例如，我们有下面的一个 Makefile：

#make 调用的隐含规则是，把[.o]的目标的依赖文件置成[.c]，并使用 C 的编译命令“cc –c $(CFLAGS) [.c]”来生成[.o]的目标。
foo : foo.o bar.o
cc –o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

我们可以注意到，这个 Makefile 中并没有写下如何生成 foo.o 和 bar.o 这两目标的规则和命令。因为 make 的“隐含规则”功能会自动为我们自动去推导这两个目标的依赖目标和生成命令。

make 会在自己的“隐含规则”库中寻找可以用的规则，如果找到，那么就会使用。如果找不到，那么就会报错。

当然，如果我们为[.o]文件书写了自己的规则，那么 make 就不会自动推导并调用隐含规则，它会按照我们写好的规则忠实地执行。

还有，在 make 的“隐含规则库”中，每一条隐含规则都在库中有其顺序，越靠前的则是越被经常使用的，所以，这会导致我们有些时候即使我们显示地指定了目标依赖，make也不会管。如下面这条规则（没有命令）：

foo.o : foo.p

依赖文件“foo.p”（Pascal 程序的源文件）有可能变得没有意义。如果目录下存在了“foo.c”文件，那么我们的隐含规则一样会生效，并会通过“foo.c”调用 C 的编译器生成foo.o 文件。因为，在隐含规则中，Pascal 的规则出现在 C 的规则之后，所以，make 找到可以生成 foo.o 的 C 的规则就不再寻找下一条规则了。 如果你确实不希望任何隐含规则推导，那么，你就不要只写出“依赖规则”，而不写命令。

11.2 常用的隐含规则

如果我们不明确地写下规则，那么，make 就会在这些规则中寻找所需要规则和命令。当然，我们也可以使用 make的参数“-r”或“–no-builtin-rules”选项来取消所有的预设置的隐含规则。

当然，即使是我们指定了“-r”参数，某些隐含规则还是会生效，因为有许多的隐含规则都是使用了“后缀规则”来定义的，所以，只要隐含规则中有“后缀列表”（也就一系统定 义 在 目 标 .SUFFIXES 的 依 赖 目 标 ）， 那 么 隐 含 规 则 就 会 生 效 。 默 认 的 后 缀 列 是：.out,.a, .ln, .o, .c, .cc, .C, .p, .f, .F, .r, .y, .l, .s, .S, .mod, .sym,.def, .h, .info, .dvi, .tex, .texinfo, .texi, .txinfo, .w, .ch .web, .sh, .elc, .el。

11.2.1 编译C程序的隐含规则

“.o”的目标的依赖目标会自动推导为“.c”，并且其生成命令是“$(CC)–c$(CPPFLAGS) $(CFLAGS)

11.2.2 编译C++程序的隐含规则

“.o”的目标的依赖目标会自动推导为“.cc”或是“.C”， 并且其生成命令是“$(CXX) –c $(CPPFLAGS) $(CFLAGS)”。 （建议使用“.cc”作为 C++源文件的后缀，而不是“.C”）

11.2.3 编译 Pascal 程序的隐含规则

“.o”的目标的依赖目标会自动推导为“.p”， 并且其生成命令是“$(PC) –c $(PFLAGS)”。

11.2.4 编译 Fortran/Ratfor 程序的隐含规则

“.o”的目标的依赖目标会自动推导为“.r”或“.F”或“.f”， 并且其生成命令是:

“.f” “$(FC) –c $(FFLAGS)”
“.F” “$(FC) –c $(FFLAGS) $(CPPFLAGS)”
“.f” “$(FC) –c $(FFLAGS) $(RFLAGS)”

11.2.5 预处理 Fortran/Ratfor 程序的隐含规则

“.f”的目标的依赖目标会自动推导为“.r”或“.F”。这个规则只是转换Ratfor 或有预处理的 Fortran 程序到一个标准的 Fortran 程序。其使用的命令是：

“.F” “$(FC) –F $(CPPFLAGS) $(FFLAGS)”
“.r” “$(FC) –F $(FFLAGS) $(RFLAGS)”

11.2.6 编译 Modula-2 程序的隐含规则

“.sym”的目标的依赖目标会自动推导为“.def”，并且其生成命令是：“$(M2C)$(M2FLAGS) $(DEFFLAGS)”。“<n.o>”的目标的依赖目标会自动推导为“<n>.mod”，并且其生成命令是：“$(M2C) $(M2FLAGS) $(MODFLAGS)”。

11.2.7 汇编和汇编预处理的隐含规则

“.o” 的目标的依赖目标会自动推导为“.s”，默认使用编译品“as”，并且其生成命令是：“$(AS) $(ASFLAGS)”。“<n>.s”的目标的依赖目标会自动推导为“<n>.S”，默认使用C预编译器“cpp”，并且其生成命令是：“$(AS) $(ASFLAGS)”。

11.2.8 链接 Object 文件的隐含规则

“”目标依赖于“ .o”，通过运行 C 的编译器来运行链接程序生成（一般是“ld”），其生成命令是：“$(CC) $(LDFLAGS) .o $(LOADLIBES) $(LDLIBS)”。这个规则对于只有一个源文件的工程有效，同时也对多个 Object 文件（由不同的源文件生成）的也有效。例如如下规则：

x : y.o z.o
#并且“x.c”、“y.c”和“z.c”都存在时，隐含规则将执行如下命令：
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

如果没有一个源文件（如上例中的 x.c）和你的目标名字（如上例中的 x）相关联，那么，你最好写出自己的生成规则，不然，隐含规则会报错的。

11.2.9 Yacc C 程序时的隐含规则

“.c”的依赖文件被自动推导为“n.y”（Yacc 生成的文件），其生成命令是：“$(YACC) $(YFALGS)”。 （“Yacc”是一个语法分析器，关于其细节请查看相关资料）

11.2.10 Lex C 程序时的隐含规则

.c”的依赖文件被自动推导为“n.l”（Lex 生成的文件），其生成命令是： “$(LEX) $(LFALGS)”。 （关于“Lex”的细节请查看相关资料）

11.2.11 Lex Ratfor 程序时的隐含规则

“.r”的依赖文件被自动推导为“n.l”（Lex 生成的文件），其生成命令是： “$(LEX) $(LFALGS)”。

11.2.12 从 C 程序、 Yacc 文件或 Lex 文件创建 Lint 库的隐含规则

“.ln” （lint 生成的文件） 的依赖文件被自动推导为“n.c”， 其生成命令是： “$(LINT) $(LINTFALGS) $(CPPFLAGS) -i”。对于“.y”和“.l”也是同样的规则。

11.3 隐含规则使用的变量

在隐含规则中的命令中，基本上都是使用了一些预先设置的变量。你可以在你的makefile 中改变这些变量的值，或是在 make 的命令行中传入这些值，或是在你的环境变量中设置这些值，无论怎么样，只要设置了这些特定的变量，那么其就会对隐含规则起作用。当然， 你也可以利用 make 的“-R”或“–no–builtin-variables”参数来取消你所定义的变量对隐含规则的作用。

例如，第一条隐含规则——编译 C 程序的隐含规则的命令是“$(CC) –c $(CFLAGS)$(CPPFLAGS)”。 Make 默认的编译命令是“cc”， 如果你把变量“$(CC)”重定义成“gcc”，把变量“$(CFLAGS)”重定义成“-g”，那么，隐含规则中的命令全部会以“gcc –c -g$(CPPFLAGS)”的样子来执行了。

我们可以把隐含规则中使用的变量分成两种：一种是命令相关的，如“CC”；一种是参数相的关，如“CFLAGS”。下面是所有隐含规则中会用到的变量：

11.3.1 关于命令的变量

AR
函数库打包程序。默认命令是“ar”。
AS
汇编语言编译程序。默认命令是“as”。
CC
C 语言编译程序。默认命令是“cc”。
CXX
C++语言编译程序。默认命令是“g++”。
CO
从 RCS 文件中扩展文件程序。默认命令是“co”。
CPP
C 程序的预处理器（输出是标准输出设备）。默认命令是“$(CC) –E”。
FC
Fortran 和 Ratfor 的编译器和预处理程序。默认命令是“f77”。
GET
从 SCCS 文件中扩展文件的程序。默认命令是“get”。
LEX
Lex 方法分析器程序（针对于 C 或 Ratfor）。默认命令是“lex”。
PC
Pascal 语言编译程序。默认命令是“pc”。
YACC
Yacc 文法分析器（针对于 C 程序）。默认命令是“yacc”。
YACCR
Yacc 文法分析器（针对于 Ratfor 程序）。默认命令是“yacc –r”。
MAKEINFO
转换 Texinfo 源文件（.texi）到 Info 文件程序。默认命令是“makeinfo”。
TEX
从 TeX 源文件创建 TeX DVI 文件的程序。默认命令是“tex”。
TEXI2DVI
从 Texinfo 源文件创建军 TeX DVI 文件的程序。默认命令是“texi2dvi”。
WEAVE
转换 Web 到 TeX 的程序。默认命令是“weave”。
CWEAVE
转换 C Web 到 TeX 的程序。默认命令是“cweave”。
TANGLE
转换 Web 到 Pascal 语言的程序。默认命令是“tangle”。
CTANGLE
转换 C Web 到 C。默认命令是“ctangle”。
RM
删除文件命令。默认命令是“rm –f”。

11.3.2 关于命令参数的变量

下面的这些变量都是相关上面的命令的参数。如果没有指明其默认值，那么其默认值都是空。

ARFLAGS
函数库打包程序 AR 命令的参数。默认值是“rv”。
ASFLAGS
汇编语言编译器参数。 （当明显地调用“.s”或“.S”文件时）。
CFLAGS
C 语言编译器参数。
CXXFLAGS
C++语言编译器参数。
COFLAGS
RCS 命令参数。
CPPFLAGS
C 预处理器参数。 （ C 和 Fortran 编译器也会用到）。
FFLAGS
Fortran 语言编译器参数。
GFLAGS
SCCS “get”程序参数。
LDFLAGS
链接器参数。 （如：“ld”）
LFLAGS
Lex 文法分析器参数。
PFLAGS
Pascal 语言编译器参数。
RFLAGS
Ratfor 程序的 Fortran 编译器参数。
YFLAGS
Yacc 文法分析器参数。

11.4 隐含规则链

有些时候，一个目标可能被一系列的隐含规则所作用。例如，一个[.o]的文件生成，可能会是先被 Yacc 的[.y]文件先成[.c]，然后再被 C 的编译器生成。我们把这一系列的隐含规则叫做“隐含规则链”。

在上面的例子中，如果文件[.c]存在，那么就直接调用 C 的编译器的隐含规则，如果没有[.c]文件，但有一个[.y]文件，那么 Yacc 的隐含规则会被调用，生成[.c]文件，然后，再调用 C 编译的隐含规则最终由[.c]生成[.o]文件，达到目标。 我们把这种[.c]的文件（或是目标），叫做中间目标。

在默认情况下，对于中间目标，它和一般的目标有两个地方所不同：第一个不同是除非中间的目标不存在，才会引发中间规则。第二个不同的是，只要目标成功产生，那么，产生最终目标过程中，所产生的中间目标文件会被以“rm -f”删除。

通常，一个被 makefile 指定成目标或是依赖目标的文件不能被当作中介。然而，你可以明显地说明一个文件或是目标是中介目标，你可以使用伪目标“.INTERMEDIATE”来强制声明。 （如：.INTERMEDIATE ： mid ）

你 也 可 以 阻 止 make 自 动 删 除 中 间 目 标 ， 要 做 到 这 一 点 ， 你 可 以 使 用 伪 目 标“.SECONDARY”来强制声明（如：.SECONDARY : sec）。你还可以把你的目标，以模式的方式来指定（如：%.o）成伪目标“.PRECIOUS”的依赖目标，以保存被隐含规则所生成的中间文件。

在“隐含规则链”中，禁止同一个目标出现两次或两次以上，这样一来，就可防止在make 自动推导时出现无限递归的情况。
Make 会优化一些特殊的隐含规则，而不生成中间文件。如，从文件“foo.c”生成目标程序“foo”，按道理，make 会编译生成中间文件“foo.o”，然后链接成“foo”，但在实际情况下，这一动作可以被一条“cc”的命令完成（cc –o foo foo.c），于是优化过的规则就不会生成中间文件。

11.5 定义模式规则

你可以使用模式规则来定义一个隐含规则。一个模式规则就好像一个一般的规则，只是在规则中，目标的定义需要有"%“字符。”%“的意思是表示一个或多个任意字符。在依赖目标中同样可以使用”%“，只是依赖目标中的”%"的取值，取决于其目标。

有一点需要注意的是，"%“的展开发生在变量和函数的展开之后，变量和函数的展开发生在 make 载入 Makefile 时，而模式规则中的”%"则发生在运行时。

11.5.1 模式规则介绍

模式规则中，至少在规则的目标定义中要包含"%“，否则，就是一般的规则。目标中的”%“定义表示对文件名的匹配，”%“表示长度任意的非空字符串。例如：”%.c"表示以".c"结尾的文件名（文件名的长度至少为 3）， 而"s.%.c"则表示以"s."开头， “.c"结尾的文件名（文件名的长度至少为 5）。如果”%“定义在目标中，那么，目标中的”%“的值决定了依赖目标中的”%“的值，也就是 说，目标中的模式的”%“决定了依赖目标中”%"的样子。例如有一个模式规则如下：

%.o : %.c ; <command ......>

其含义是，指出了怎么从所有的[.c]文件生成相应的[.o]文件的规则。如果要生成的目标是"a.o b.o"，那么"%c"就是"a.c b.c"。

一旦依赖目标中的"%"模式被确定，那么，make 会被要求去匹配当前目录下所有的文件名，一旦找到，make 就会规则下的命令，所以，在模式规则中，目标可能会是多个的，如果有模式匹配出多个目标，make 就会产生所有的模式目标，此时，make 关心的是依赖的文件名和生成目标的命令这两件事。

11.5.2 模式规则介绍

下面这个例子表示了,把所有的[.c]文件都编译成[.o]文件

%.o : %.c
$(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

其中，"$@"表示所有的目标的挨个值，"$<“表示了所有依赖目标的挨个值。这些奇怪的变量我们叫"自动化变量” 。

下面的这个例子中有两个目标是模式的：

%.tab.c %.tab.h: %.y
bison -d $<

这 条 规 则 告 诉 make 把 所 有 的 [.y] 文 件 都 以 “bison -d .y” 执 行 ， 然 后 生 成".tab.c"和".tab.h"文件。 （其中，"“表示一个任意字符串）。如果我们的执行程序 “foo” 依 赖 于 文 件 “parse.tab.o” 和 “scan.o” ， 并 且 文 件 “scan.o” 依 赖 于 文 件"parse.tab.h”，如果"parse.y"文件被更新了，那么根据上述的规则，"bison -d parse.y"就会被执行一次，于是， "parse.tab.o"和"scan.o"的依赖文件就齐了。（假设， "parse.tab.o"由"parse.tab.c"生成，和"scan.o"由"scan.c"生成，而"foo"由"parse.tab.o"和"scan.o"链接生成，而且 foo 和其[.o]文件的依赖关系也写好，那么，所有的目标都会得到满足）。

11.5.3 自动化变量

所谓自动化变量，就是这种变量会把模式中所定义的一系列的文件自动地挨个取出，直至所有的符合模式的文件都取完了。这种自动化变量只应出现在规则的命令中。

下面是所有的自动化变量及其说明：

$@
表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，"$@"就是匹配于目标中模式定义的集合。
$%
仅当目标是函数库文件中，表示规则中的目标成员名。例如，如果一个目标是"foo.a(bar.o)"，那么，"$%"就是"bar.o"，"$@"就是"foo.a"。如果目标不是函数库文件（Unix下是[.a]，Windows 下是[.lib]），那么，其值为空。
$<
依赖目标中的第一个目标名字。如果依赖目标是以模式（ 即"%"）定义的，那么"$<"将是符合模式的一系列的文件集。注意，其是一个一个取出来的。
$?
所有比目标新的依赖目标的集合。以空格分隔。
$^
所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。
$+
这个变量很像"$^"，也是所有依赖目标的集合。只是它不去除重复的依赖目标。
$*
这个变量表示目标模式中"%"及其之前的部分。如果目标是"dir/a.foo.b"，并且目标的模式是"a.%.b"，那么，"$*"的值就是"dir/a.foo"。这个变量对于构造有关联的文件名是比较有较。如果目标中没有模式的定义，那么"$*"也就不能被推导出，但是，如果目标文件的后缀是 make 所识别的，那么"$*"就是除了后缀的那一部分。例如：如果目标是"foo.c"，因为".c"是 make 所能识别的后缀名，所以，"$*"的值就是"foo"。这个特性是 GNU make 的，很有可能不兼容于其它版本的 make，所以，你应该尽量避免使用"$*"，除非是在隐含规则或是静态模式中。如果目标中的后缀是 make 所不能识别的，那么"$*"就是空值。

当你希望只对更新过的依赖文件进行操作时，"$?“在显式规则中很有用，例如，假设有一个函数库文件叫"lib”，其由其它几个 object 文件更新。那么把 object 文件打包的比较有效率的 Makefile 规则是：

lib : foo.o bar.o lose.o win.o
ar r lib $?

在上述所列出来的自动量变量中。四个变量（$@、$<、 %、 *）在扩展时只会有一个文件，而另三个的值是一个文件列表。这七个自动化变量还可以取得文件的目录名或是在当前目录下的符合模式的文件名，只需要搭配上"D"或"F"字样。这是 GNU make 中老版本的特性，在新版本中，我们使用函数"dir"或"notdir"就可以做到了。"D"的含义就是 Directory，就是目录，"F"的含义就是 File，就是文件。

下面是对于上面的七个变量分别加上"D"或是"F"的含义：

$(@D)
表示"$@"的目录部分（不以斜杠作为结尾），如果"$@"值是"dir/foo.o"，那么"$(@D)"就是"dir"，而如果"$@"中没有包含斜杠的话，其值就是"."（当前目录）。
$(@F)
表示"$@"的文件部分，如果"$@"值是"dir/foo.o"， 那么"$(@F)"就是"foo.o"，"$(@F)"相当于函数"$(notdir $@)"。
"$(*D)"
"$(*F)"
和上面所述的同理，也是取文件的目录部分和文件部分。对于上面的那个例子， "$(*D)"返回"dir"，而"$(*F)"返回"foo"
"$(%D)"
"$(%F)"
分别表示了函数包文件成员的目录部分和文件部分。这对于形同"archive(member)"形式的目标中的"member"中包含了不同的目录很有用。
"$(<D)"
"$(<F)"
分别表示依赖文件的目录部分和文件部分。
"$(^D)"
"$(^F)"
分别表示所有依赖文件的目录部分和文件部分。 （无相同的）
"$(+D)"
"$(+F)"
分别表示所有依赖文件的目录部分和文件部分。 （可以有相同的）
"$(?D)"
"$(?F)"
分别表示被更新的依赖文件的目录部分和文件部分

最后想提醒一下的是，对于"$<"，为了避免产生不必要的麻烦，我们最好给$后面的那个特定字符都加上圆括号，比如，"$(<)"就要比"$<"要好一些。

还得要注意的是，这些变量只使用在规则的命令中，而且一般都是"显式规则"和"静态模式规则"（参见前面"书写规则"一章）。其在隐含规则中并没有意义。

11.5.4 模式的匹配

一般来说，一个目标的模式有一个有前缀或是后缀的"%“，或是没有前后缀，直接就是一个”%“。因为”%“代表一个或多个字符，所以在定义好了的模式中，我们把”%“所匹配的内容叫做"茎”，例如"%.c"所匹配的文件"test.c"中"test"就是"茎"。因为在目标和依赖目标中同时有"%“时，依赖目标的"茎"会传给目标，当做目标中的"茎”。

当一个模式匹配包含有斜杠（实际也不经常包含）的文件时，那么在进行模式匹配时，目录部分会首先被移开，然后进行匹配，成功后，再把目录加回去。在进行"茎"的传递时，我们需要知道这个步骤。 例如有一个模式"e%t"，文件"src/eat"匹配于该模式， 于是"src/a"就是其"茎"，如果这个模式定义在依赖目标中，而被依赖于这个模式的目标中又有个模式"c%r"，那么，目标就是"src/car"。 （"茎"被传递）

11.5.5 重载内建隐含规则

你可以重载内建的隐含规则（或是定义一个全新的），例如你可以重新构造和内建隐含规则不同的命令，如：

%.o : %.c
$(CC) -c $(CPPFLAGS) $(CFLAGS) -D$(date)

你可以取消内建的隐含规则，只要不在后面写命令就行。如：

%.o : %.s

同样，你也可以重新定义一个全新的隐含规则，其在隐含规则中的位置取决于你在哪里写下这个规则。朝前的位置就靠前。

11.6 老式风格的“后缀规则”

后缀规则是一个比较老式的定义隐含规则的方法。后缀规则会被模式规则逐步地取代。因为模式规则更强更清晰。为了和老版本的 Makefile 兼容，GNU make 同样兼容于这些东西。后缀规则有两种方式：“双后缀"和"单后缀”。

双后缀规则定义了一对后缀：目标文件的后缀和依赖目标（源文件）的后缀。如".c.o"相当于"%o : %c"。单后缀规则只定义一个后缀，也就是源文件的后缀。如".c"相当于"% :%.c"。

后缀规则中所定义的后缀应该是 make 所认识的，如果一个后缀是 make 所认识的，那么这个规则就是单后缀规则，而如果两个连在一起的后缀都被 make 所认识，那就是双后缀规则。例如：“.c"和”.o"都是 make 所知道。因而，如果你定义了一个规则是".c.o"那么其就是双后缀规则，意义就是".c"是源文件的后缀，".o"是目标文件的后缀。如下示例：

.c.o:
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<

后缀规则不允许任何的依赖文件，如果有依赖文件的话，那就不是后缀规则，那些后缀统统被认为是文件名，如：

.c.o: foo.h
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<

这个例子，就是说，文件".c.o"依赖于文件"foo.h"，而不是我们想要的这样：

%.o: %.c foo.h
$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<

后缀规则中，如果没有命令，那是毫无意义的。因为他也不会移去内建的隐含规则。

而要让 make 知道一些特定的后缀，我们可以使用伪目标".SUFFIXES"来定义或是删除，如：

#把后缀.hack 和.win 加入后缀列表中的末尾 
SUFFIXES: .hack .win

.SUFFIXES: # 删除默认的后缀
.SUFFIXES: .c .o .h # 定义自己的后缀

先清楚默认后缀，后定义自己的后缀列表。
make 的参数"-r"或"-no-builtin-rules"也会使用得默认的后缀列表为空。而变量"SUFFIXE"被用来定义默认的后缀列表，你可以用".SUFFIXES"来改变后缀列表，但请不要改变变量"SUFFIXE"的值。

11.7 隐含规则搜索算法

比如我们有一个目标叫 T。下面是搜索目标 T 的规则的算法。请注意，在下面，我们没有提到后缀规则，原因是，所有的后缀规则在 Makefile 被载入内存时，会被转换成模式规则。如果目标是"archive(member)"的函数库文件模式，那么这个算法会被运行两次，第一次是找目标 T，如果没有找到的话，那么进入第二次，第二次会把"member"当作 T 来搜索。

1、把 T 的目录部分分离出来。叫 D，而剩余部分叫 N。（如：如果 T 是"src/foo.o"，那么，D 就是"src/“，N 就是"foo.o”）
2、创建所有匹配于 T 或是 N 的模式规则列表。
3、如果在模式规则列表中有匹配所有文件的模式，如"%“，那么从列表中移除其它的模式。
4、移除列表中没有命令的规则。
5、对于第一个在列表中的模式规则：
1）推导其"茎"S，S 应该是 T 或是 N 匹配于模式中”%“非空的部分。
2）计算依赖文件。把依赖文件中的”%“都替换成"茎"S。如果目标模式中没有包含斜框字符，而把 D 加在第一个依赖文件的开头。
3）测试是否所有的依赖文件都存在或是理当存在。（如果有一个文件被定义成另外一个规则的目标文件，或者是一个显式规则的依赖文件， 那么这个文件就叫"理当存在”）
4）如果所有的依赖文件存在或是理当存在，或是就没有依赖文件。那么这条规则将被采用，退出该算法。
6、如果经过第 5 步，没有模式规则被找到，那么就做更进一步的搜索。对于存在于列表中的第一个模式规则：
1）如果规则是终止规则，那就忽略它，继续下一条模式规则。
2）计算依赖文件。 （同第 5 步）
3）测试所有的依赖文件是否存在或是理当存在。
4）对于不存在的依赖文件，递归调用这个算法查找他是否可以被隐含规则找到。

5）如果所有的依赖文件存在或是理当存在，或是就根本没有依赖文件。那么这条规则被采用，退出该算法。
7、如果没有隐含规则可以使用，查看".DEFAULT"规则，如果有，采用，把".DEFAULT"的命令给 T 使用。
一旦规则被找到，就会执行其相当的命令，而此时，我们的自动化变量的值才会生成

十二 使用make更新函数库文件

函数库文件也就是对 Object 文件（程序编译的中间文件）的打包文件。在 Unix 下，一般是由命令"ar"来完成打包工作。

12.1 函数库文件的成员

一个函数库文件由多个文件组成。你可以以如下格式指定函数库文件及其组成：archive(member)这个不是一个命令，而一个目标和依赖的定义。一般来说，这种用法基本上就是为了"ar"命令来服务的。如：

foolib(hack.o) : hack.o
ar cr foolib hack.o

如果要指定多个 member，那就以空格分开，如：

foolib(hack.o kludge.o)

#其等价于：

foolib(hack.o) foolib(kludge.o)

你还可以使用 Shell 的文件通配符来定义，如：

foolib(*.o)

12.2 函数库成员的隐含规则

当 make 搜索一个目标的隐含规则时，一个特殊的特性是，如果这个目标是"a(m)“形式的，其会把目标变成”(m)“。于是，如果我们的成员是”%.o"的模式定义，并且如果我们使用"make foo.a(bar.o)"的形式调用 Makefile 时，隐含规则会去找"bar.o"的规则，如果没有定义 bar.o 的规则，那么内建隐含规则生效，make 会去找 bar.c 文件来生成 bar.o，如果找得到的话，make 执行的命令大致如下：

cc -c bar.c -o bar.o
ar r foo.a bar.o
rm -f bar.o

还有一个变量要注意的是"$%"，这是专属函数库文件的自动化变量。

12.3 函数库文件的后缀规则

你可以使用"后缀规则"和"隐含规则"来生成函数库打包文件，如：

.c.a:
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
$(AR) r $@ $*.o
$(RM) $*.o

#其等效于：

(%.o) : %.c
$(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
$(AR) r $@ $*.o
$(RM) $*.o  

12.4 注意事项

在进行函数库打包文件生成时，请小心使用 make 的并行机制（"-j"参数）。如果多个ar 命令在同一时间运行在同一个函数库打包文件上，就很有可以损坏这个函数库文件。所以，在 make 未来的版本中，应该提供一种机制来避免并行操作发生在函数打包文件上。

十三 Makefile参数选项

13.1 -D选项更改宏定义

在Makefile中我们可以通过宏定义来控制源程序的编译。只要在Makefile中的CFLAGS中通过选项-D来指定你于定义的宏即可。

C_DEFINES += -DSK_RELEASE

用于将-D后面的SK_RELEASE传递给源代码使用，就相当于在源代码中使用：

#define SK_RELEASE		#宏定义

#Makefile文件
CC_OPTS += -DMakefle_D=2

all:testD
    echo "done"
testD:testD.c
    gcc testD.c -o testD $(CC_OPTS)

#testD.c文件
#include<stdio.h>
int main()
{
    printf("Makefle_D = %d\n", Makefle_D);
}

注：改动-DMakefle_D=2为-DMakefle_D=3或者-DMakefle_D=4，编译测试

发现改动后，testD.c并不会重新编译。所以在Makefile里面改宏定义，记得要clean

13.2 make 参数 ARCH与CROSS_COMPILE

make ARCH=arm  CROSS_COMPILE=arm-none-linux-gnueabi-

ARCH即architecture,就是选择编译哪一种cpu architecture，也就是编译arch/目录下的哪一个子目录

CROSS_COMPILE。如指定make ARCH=arm就是编译arch/arm下的代码。如果不指定，make将使用本机（用什么机器编译就是什么）的cpu作为缺省ARCH.注意：arch/arm下不但有arm体系架构特有的代码，还有arm特有的kconfig,也就是配置选项，所以在make menuconfig，make xxxx_defconfig的时候也必须指定ARCH＝arm。

即交叉编译器的前缀（prefix)，也就是选择将代码编译成目标cpu的指令的工具，如指定make CROSS_COMPILE=arm-none-linux-gnueabi-就是使用arm-none-linux-gnueabi-gcc, arm-none-linux-gnueabi-ld等工具将代码编译成arm的可执行指令。
如果不指定CROSS_COMPILE参数，make时将认为prefix为空，即使用gcc来编译。这里cross_compile的设置，是假定所用的交叉工具链的gcc程序名称为arm-linux-gcc。如果实际使用的gcc名称是some-thing-else-gcc，则这里照葫芦画瓢填some-thing-else-即可。总之，要省去名称中最后的gcc那3个字母。

1）ARCH=arm 表示ARCH给出了目标处理器的架构这里用的是arm 处理器。

2）CROSS_COMPILE给出了编译程序所用的交叉工具链的名称，比如：CROSS_COMPILE=arm-none-linux-

3）通过这个命令，把这些参数传递给Makefile中的预留参数，程序就可以顺利编译下去了

13.3 make clean

#清除上次的make命令所产生的object文件（后缀为“.o”的文件）及可执行文件
make clean
 
#将编译成功的可执行文件安装到系统目录中，一般为/usr/local/bin目录
make install
 
#产生发布软件包文件（即distribution package）。
#这个命令将会将可执行文件及相关文件打包成一个tar.gz压缩的文件用来作为发布软件的软件包
make dist
 
#生成发布软件包并对其进行测试检查，以确定发布包的正确性。
#这个操作将自动把压缩包文件解开，然后执行configure命令，并且执行make,来确认编译不出现
make distcheck

#类似make clean,但同时也将configure生成的文件全部删除掉，包括Makefile文件。
make distclean