Makefile六层功力的锻炼（四）

Makefile六层功力的锻炼（四）

这里主要对Makefile书写命令和变量有一个更深层次的学习，三、四、五三层功力是需要一定时间去理解和消化的，不要着急，慢慢来。

一、书写命令

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

我们在 UNIX 下可能会使用不同的 Shell，但是 make 的命令默认是被“/bin/sh”——UNIX
的标准 Shell 解释执行的。除非你特别指定一个其它的 Shell。Makefile 中，“#”是注
释符，很像 C/C++中的“//”，其后的本行字符都被注释。

1.显示命令

通常，make 会把其要执行的命令行在命令执行前输出到屏幕上。当我们用“@”字符在命令
行前，那么，这个命令将不被 make 显示出来，最具代表性的例子是，我们用这个功能来像
屏幕显示一些信息。如：

@echo 正在编译 XXX 模块......

当 make 执行时，会输出“正在编译 XXX 模块……”字串，但不会输出命令，如果没有
“@”，那么，make 将输出：

echo 正在编译 XXX 模块......
正在编译 XXX 模块......

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

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

2.命令执行

当依赖目标新于目标时，也就是当规则的目标需要被更新时，make 会一条一条的执行其后
的命令。需要注意的是，如果你要让上一条命令的结果应用在下一条命令时，你应该使用分
号分隔这两条命令。比如你的第一条命令是 cd 命令，你希望第二条命令得在 cd 之后的基础
上运行，那么你就不能把这两条命令写在两行上，而应该把这两条命令写在一行上，用分号
分隔。如：

示例一：

exec:
    cd /home/hchen
    pwd

示例二：

exec:
    cd /home/hchen; pwd

当我们执行“make exec”时，第一个例子中的 cd 没有作用，pwd 会打印出当前的 Makefile
目录，而第二个例子中，cd 就起作用了，pwd 会打印出“/home/hchen”。

make 一般是使用环境变量 SHELL 中所定义的系统 Shell 来执行命令，默认情况下使用
UNIX 的标准 Shell——/bin/sh 来执行命令。但在 MS-DOS 下有点特殊，因为 MS-DOS
下没有 SHELL 环境变量，当然你也可以指定。如果你指定了 UNIX 风格的目录形式，首先，
make 会在 SHELL 所指定的路径中找寻命令解释器，如果找不到，其会在当前盘符中的当前
目录中寻找，如果再找不到，其会在 PATH 环境变量中所定义的所有路径中寻找。MS-DOS
中，如果你定义的命令解释器没有找到，其会给你的命令解释器加上诸如“.exe”、“.com”、
“.bat”、“.sh”等后缀。

3.命令出错

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

有些时候，命令的出错并不表示就是错误的。例如 mkdir 命令，我们一定需要建立一个目
录，如果目录不存在，那么 mkdir 就成功执行，万事大吉，如果目录存在，那么就出错了。
我们之所以使用 mkdir 的意思就是一定要有这样的一个目录，于是我们就不希望 mkdir 出
错而终止规则的运行。

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

clean:
    -rm -f *.o

还有一个全局的办法是，给 make 加上“-i”或是“–ignore-errors”参数，那么，
Makefile 中所有命令都会忽略错误。而如果一个规则是以“.IGNORE”作为目标的，那么
这个规则中的所有命令将会忽略错误。这些是不同级别的防止命令出错的方法，你可以根据
你的不同喜欢设置。

还有一个要提一下的 make 的参数的是“-k”或是“–keep-going”，这个参数的意思是，
如果某规则中的命令出错了，那么就终目该规则的执行，但继续执行其它规则。

4.嵌套执行make

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

例如，我们有一个子目录叫 subdir，这个目录下有个 Makefile 文件，来指明了这个目录
下文件的编译规则。那么我们总控的 Makefile 可以这样书写：

subsystem:
    cd subdir && $(MAKE)

其等价于：

subsystem:
    $(MAKE) -C subdir

定义$(MAKE)宏变量的意思是，也许我们的 make 需要一些参数，所以定义成一个变量比较
利于维护。这两个例子的意思都是先进入“subdir”目录，然后执行 make 命令。

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

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

export <variable ...>

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

unexport <variable ...>

如：
示例一：

export variable = value

其等价于：

variable = value
export variable

其等价于

export variable := value

其等价于

variable := value
export variable

示例二：

export variable += value

其等价于：

variable += value
export variable

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

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

但是 make 命令中的有几个参数并不往下传递，它们是“-C”,“-f”,“-h”“-o”和“-W”
（有关 Makefile 参数的细节将在后面说明），如果你不想往下层传递参数，那么，你可以
这样来：

subsystem:
    cd subdir && $(MAKE) MAKEFLAGS=

如果你定义了环境变量 MAKEFLAGS，那么你得确信其中的选项是大家都会用到的，如果其
中有“-t”,“-n”,和“-q”参数，那么将会有让你意想不到的结果，或许会让你异常地
恐慌。

还有一个在“嵌套执行”中比较有用的参数，“-w”或是“–print-directory”会在 make
的过程中输出一些信息，让你看到目前的工作目录。比如，如果我们的下级 make 目录是“/home/hchen/gnu/make”，如果我们使用“make -w”来执行，那么当进入该目录时，
我们会看到：

make: Entering directory `/home/hchen/gnu/make'.

而在完成下层 make 后离开目录时，我们会看到：

make: Leaving directory `/home/hchen/gnu/make'

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

5.定义命令包

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

define run-yacc
yacc $(firstword $^)
mv y.tab.c $@
endef

这里，“run-yacc”是这个命令包的名字，其不要和 Makefile 中的变量重名。在“define”
和“endef”中的两行就是命令序列。这个命令包中的第一个命令是运行 Yacc 程序，因为
Yacc 程序总是生成“y.tab.c”的文件，所以第二行的命令就是把这个文件改改名字。还
是把这个命令包放到一个示例中来看看吧。

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。这样可以避免和系统的变量冲突，而发生意外的事情。

有一些变量是很奇怪字串，如“ $<”、“$ @”等，这些是自动化变量，我会在后面介绍。

1.变量的基础

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

变量可以使用在许多地方，如规则中的“目标”、“依赖”、“命令”以及新的变量中。先看一
个例子：

objects = program.o foo.o utils.o
program : $(objects)
    cc -o program $(objects)

$(objects) : defs.h

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

foo = c
prog.o : prog.$(foo)
    $(foo)$(foo) -$(foo) prog.$(foo)

展开后得到：

prog.o : prog.c
    cc -c prog.c

当然，千万不要在你的 Makefile 中这样干，这里只是举个例子来表明 Makefile 中的变
量在使用处展开的真实样子。可见其就是一个“替代”的原理。

另外，给变量加上括号完全是为了更加安全地使用这个变量，在上面的例子中，如果你不想
给变量加上括号，那也可以，但我还是强烈建议你给变量加上括号。

2.变量中的变量

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

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

foo = $(bar)
bar = $(ugh)
ugh = Huh?
all:
echo $(foo)

我们执行“make all”将会打出变量 $(foo)的值是“Huh?”（$ (foo)的值是 $(bar)，$ (bar)的值是 $(ugh)，$ (ugh)的值是“Huh?”）可见，变量是可以使用后面的变量来定
义的。

这个功能有好的地方，也有不好的地方，好的地方是，我们可以把变量的真实值推到后面来
定义，如：

CFLAGS = $(include_dirs) -O
include_dirs = -Ifoo -Ibar

当“CFLAGS”在命令中被展开时，会是“-Ifoo -Ibar -O”。但这种形式也有不好的地
方，那就是递归定义，如：

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

这会让 make 陷入无限的变量展开过程中去，当然，我们的 make 是有能力检测这样的定义，
并会报错。还有就是如果在变量中使用函数，那么，这种方式会让我们的 make 运行时非常
慢，更糟糕的是，他会使用得两个 make 的函数“wildcard”和“shell”发生不可预知
的错误。因为你不会知道这两个函数会被调用多少次。

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

x := foo
y := $(x) bar
x := later

其等价于：

y := foo bar
x := later

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

y := $(x) bar
x := foo

那么，y 的值是“bar”，而不是“foo bar”。

上面都是一些比较简单的变量使用了，让我们来看一个复杂的例子，其中包括了 make 的函
数、条件表达式和一个系统变量“MAKELEVEL”的使用：

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

关于条件表达式和函数，我们在后面再说，对于系统变量“MAKELEVEL”，其意思是，如果
我们的 make 有一个嵌套执行的动作（参见前面的“嵌套使用 make”），那么，这个变量会
记录了我们的当前 Makefile 的调用层数。

下面再介绍两个定义变量时我们需要知道的，请先看一个例子，如果我们要定义一个变量，
其值是一个空格，那么我们可以这样来：

nullstring :=
space := $(nullstring) # end of the line

nullstring 是一个 Empty 变量，其中什么也没有，而我们的 space 的值是一个空格。因
为在操作符的右边是很难描述一个空格的，这里采用的技术很管用，先用一个 Empty 变量
来标明变量的值开始了，而后面采用“#”注释符来表示变量定义的终止，这样，我们可以
定义出其值是一个空格的变量。请注意这里关于“#”的使用，注释符“#”的这种特性值得
我们注意，如果我们这样定义一个变量：

dir := /foo/bar # directory to put the frobs in

dir 这个变量的值是“/foo/bar”，后面还跟了 4 个空格，如果我们这样使用这样变量来指
定别的目录——“$(dir)/file”那么就完蛋了。

还有一个比较有用的操作符是“?=”，先看示例：

FOO ?= bar

其含义是，如果 FOO 没有被定义过，那么变量 FOO 的值就是“bar”，如果 FOO 先前被定义
过，那么这条语将什么也不做，其等价于：

ifeq ($(origin FOO), undefined)
FOO = bar
endif

3.变量高级用法

这里介绍两种变量的高级使用方法，第一种是变量值的替换。

我们可以替换变量中的共有的部分，其格式是“ $(var:a=b)”或是“$ {var:a=b}”，其
意思是，把变量“var”中所有以“a”字串“结尾”的“a”替换成“b”字串。这里的“结
尾”意思是“空格”或是“结束符”。

还是看一个示例吧：

foo := a.o b.o c.o
bar := $(foo:.o=.c)

这个示例中，我们先定义了一个“ $(foo)”变量，而第二行的意思是把“$ (foo)”中所有
以“.o”字串“结尾”全部替换成“.c”，所以我们的“$(bar)”的值就是“a.c b.c c.c”。

另外一种变量替换的技术是以“静态模式”（参见前面章节）定义的，如：

foo := a.o b.o c.o
bar := $(foo:%.o=%.c)

这依赖于被替换字串中的有相同的模式，模式中必须包含一个“%”字符，这个例子同样让
$(bar)变量的值为“a.c b.c c.c”。

第二种高级用法是——“把变量的值再当成变量”。先看一个例子：

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

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

我们还可以使用更多的层次：

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

这里的$(a)的值是“u”，相关的推导留给读者自己去做吧。

让我们再复杂一点，使用上“在变量定义中使用变量”的第一个方式，来看一个例子：

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

这里的 $($ (x))被替换成了 $($ (y))，因为 $(y)值是“z”，所以，最终结果是：a:=$ (z)，
也就是“Hello”。
再复杂一点，我们再加上函数：

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”。（喔，好不容易）

在这种方式中，或要可以使用多个变量来组成一个变量的名字，然后再取其值：

first_second = Hello
a = first
b = second
all = $($a_$b)

这里的“ $a_$ b”组成了“first_second”，于是，$(all)的值就是“Hello”。

再来看看结合第一种技术的例子：

a_objects := a.o b.o c.o
1_objects := 1.o 2.o 3.o
sources := $($(a1)_objects:.o=.c)

这个例子中，如果 $(a1)的值是“a”的话，那么，$ (sources)的值就是“a.c b.c c.c”；
如果 $(a1)的值是“1”，那么$ (sources)的值是“1.c 2.c 3.c”。

再来看一个这种技术和“函数”与“条件语句”一同使用的例子：

ifdef do_sort
func := sort
else
func := strip
endif
bar := a d b g q c
foo := $($(func) $(bar))

这个示例中，如果定义了“do_sort”，那么：foo := $(sort a d b g q c)，于是$ (foo)
的值就是“a b c d g q”，而如果没有定义“do_sort”，那么：foo := $(sort a d
b g q c)，调用的就是 strip 函数。

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

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

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

4.追加变量值

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

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 被追加进去了）

使用“+=”操作符，可以模拟为下面的这种例子：

objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o

所不同的是，用“+=”更为简洁。

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

variable := value
variable += more

等价于：

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

但如果是这种情况：

variable = value
variable += more

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

5.override指示符

如果有变量是通常 make 的命令行参数设置的，那么 Makefile 中对这个变量的赋值会被忽
略。如果你想在 Makefile 中设置这类参数的值，那么，你可以使用“override”指示符。
其语法是：

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

当然，你还可以追加：

override <variable> += <more text>

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

ovveride 指示符，如：
override define foo
bar
endef

6.多行变量

还有一种设置变量值的方法是使用 define 关键字。使用 define 关键字设置变量的值可以
有换行，这有利于定义一系列的命令（前面我们讲过“命令包”的技术就是利用这个关键字）。

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

下面的这个示例展示了 define 的用法：

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

7.环境变量

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

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

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

当然，我并不推荐把许多的变量都定义在系统环境中，这样，在我们执行不用的 Makefile
时，拥有的是同一套系统变量，这可能会带来更多的麻烦。

8.目标变量

前面我们所讲的在 Makefile 中定义的变量都是“全局变量”，在整个文件，我们都可以访
问这些变量。当然，“自动化变量”除外，如“$<”等这种类量的自动化变量就属于“规则
型变量”，这种变量的值依赖于规则的目标和依赖目标的定义。

当然，我样同样可以为某个目标设置局部变量，这种变量被称为“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.o foo.o bar.o 的规则），$ (CFLAGS)的值都是“-g”

9.模式变量

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

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

%.o : CFLAGS = -O

同样，模式变量的语法和“目标变量”一样：

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

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

三、最后

这里我们详细了解了书写命令和使用变量的内容，需要多多来看几次，练几次来掌握相关的语法。下一层就是使用函数了。