前言

对于一个看不懂Makefile构建文件规则的人来说，这个Makefile语法和shell语法是真不一样，但是又引用了部分shell语法，可以说是shell语法的子类，Makefile语法继承了它。

和shell语法不一样，这个更难一点，而且不太容易懂，所以后续还会持续更新这篇文章。

文章目录

前言
一、Make命令
二、Makefile文件的格式
- 2.1、概述
- 2.2、目标（target）
- 2.3、前置条件（prerequisites）
- 2.4、命令（commands）
三、Makefile文件的语法
- 3.1 注释
- 3.2 回声（echoing）
- 3.3 通配符
- 3.4 模式匹配
- 3.5 变量和赋值符
- 3.6 内置变量（Implicit Variables）
- 3.7 自动变量（Automatic Variables）
- - 1）$@
  - 2）$<
  - 3）$?
  - 4）$^
  - 5）$*
  - 6）$(@D) 和 $(@F)
  - 7）$(<D) 和 $(<F)
- 3.8 判断和循环
- 3.9 函数
- - （1）shell 函数
  - （2）wildcard 函数
  - （3）subst 函数
  - （4）patsubst函数
  - （5）替换后缀名
四、Makefile 的实例
- （1）执行多个目标
- （2）编译C语言项目
五、Makefile的特殊字符

一、Make命令

Make是最常用的构建工具，诞生于1977年，主要用于C语言的项目。但是实际上，任何只要某个文件有变化，就要重新构建的项目，都可以用Make构建。

编译（compile）：代码变成可执行文件
构建（build）：先编译这个，还是先编译那个呢？（即编译的安排）

AS的Gradle就是一个代码构建工具。

比如，要做出文件a.txt，就可以执行下面的命令。

$ make a.txt

但是，如果你真的输入这条命令，它并不会起作用。因为Make命令本身并不知道，如何做出a.txt，需要有人告诉它，如何调用其他命令完成这个目标。

比如，假设文件 a.txt 依赖于 b.txt 和 c.txt ，是后面两个文件连接（cat命令）的产物。那么，make 需要知道下面的规则。

a.txt: b.txt c.txt
    cat b.txt c.txt > a.txt

也就是说，make a.txt 这条命令的背后，实际上分成两步：

第一步，确认 b.txt 和 c.txt 必须已经存在
第二步，使用 cat 命令将这个两个文件合并，输出为新文件。

像这样的规则，都写在一个叫做Makefile的文件中，Make命令依赖这个文件进行构建。

Makefile文件也可以写为makefile，或者用命令行参数指定为其他文件名。

$ make -f rules.txt
# 或者
$ make --file=rules.txt

上面代码指定make命令依据rules.txt文件中的规则，进行构建。

总之，make只是一个根据指定的Shell命令进行构建的工具。它的规则很简单，你规定要构建哪个文件、它依赖哪些源文件，当那些文件有变动时，如何重新构建它。

二、Makefile文件的格式

构建规则都写在Makefile文件里面，要学会如何Make命令，就必须学会如何编写Makefile文件。

2.1、概述

Makefile文件由一系列规则（rules）构成。每条规则的形式如下。

<target> : <prerequisites> 
[tab]  <commands>

上面第一行冒号前面的部分，叫做"目标"（target），冒号后面的部分叫做"前置条件"（prerequisites）；第二行必须由一个tab键起首，后面跟着"命令"（commands）。

"目标"是必需的，不可省略；"前置条件"和"命令"都是可选的，但是两者之中必须至少存在一个。

每条规则就明确两件事：

构建目标的前置条件是什么？
如何构建？

下面就详细讲解，每条规则的这三个组成部分。

2.2、目标（target）

一个目标（target）就构成一条规则。目标通常是文件名，指明Make命令所要构建的对象，比如上文的 a.txt 。目标可以是一个文件名，也可以是多个文件名，之间用空格分隔。

除了文件名，目标还可以是某个操作的名字，这称为"伪目标"（phony target）。

clean:
      rm *.o

上面代码的目标是clean，它不是文件名，而是一个操作的名字，属于"伪目标 "。

这句代码作用是删除对象文件。

$ make  clean

但是，如果当前目录中，正好有一个文件叫做clean，那么这个命令不会执行。因为Make发现clean文件已经存在，就认为没有必要重新构建了，就不会执行指定的rm命令。

为了避免这种情况，可以明确声明clean是"伪目标"，写法如下。

.PHONY: clean
clean:
        rm *.o temp

声明clean是"伪目标"之后，make就不会去检查是否存在一个叫做clean的文件，而是每次运行都执行对应的命令。像.PHONY这样的内置目标名还有不少，可以查看手册。

如果Make命令运行时没有指定目标，默认会执行Makefile文件的第一个目标。

$ make

上面代码执行Makefile文件的第一个目标。

.PHONY

有一个在 Makefile 文件中常见的关键字，那就是 .PHONY。

.PHONY 是一个特殊的目标（target），用于声明一组“伪目标”，这些伪目标不代表真正的文件或者动作，而是代表需要运行的操作或任务名称。

例如:

.PHONY: all clean

all:
    gcc -o main main.c

clean:
    rm -f main

在这个例子中，我们使用 .PHONY 关键字来定义 all 和 clean 两个目标。在执行 make 命令时，可以通过指定这些目标来运行对应的操作，例如 make all 或 make clean。

需要注意的是，定义了伪目标后，并不会检查对应的文件是否存在或是否需要更新。相反，Makefile 将直接执行对应的命令，而不管是否已经有对应的文件存在。因此，定义伪目标需要通过其他方式确保其正确执行，例如在规则中加入必要的依赖项或者命令验证。

总之，.PHONY 关键字是用于定义伪目标的常用技巧，可以让 Makefile 文件更加清晰和易于维护。

2.3、前置条件（prerequisites）

前置条件通常是一组文件名，之间用空格分隔。它指定了"目标"是否重新构建的判断标准：只要有一个前置文件不存在，或者有过更新（前置文件的last-modification时间戳比目标的时间戳新），"目标"就需要重新构建。

result.txt: source.txt
    cp source.txt result.txt

上面代码中，构建 result.txt 的前置条件是 source.txt 。如果当前目录中，source.txt 已经存在，那么make result.txt可以正常运行，否则必须再写一条规则，来生成 source.txt 。

source.txt:
    echo "this is the source" > source.txt

上面代码中，source.txt后面没有前置条件，就意味着它跟其他文件都无关，只要这个文件还不存在，每次调用make source.txt，它都会生成。

$ make result.txt
$ make result.txt

上面命令连续执行两次make result.txt。第一次执行会先新建 source.txt，然后再新建 result.txt。第二次执行，Make发现 source.txt 没有变动（时间戳晚于 result.txt），就不会执行任何操作，result.txt 也不会重新生成。

如果需要生成多个文件，往往采用下面的写法。

source: file1 file2 file3

上面代码中，source 是一个伪目标，只有三个前置文件，没有任何对应的命令。

$ make source

执行make source命令后，就会一次性生成 file1，file2，file3 三个文件。这比下面的写法要方便很多。

$ make file1
$ make file2
$ make file3

2.4、命令（commands）

命令（commands）表示如何更新目标文件，由一行或多行的Shell命令组成。它是构建"目标"的具体指令，它的运行结果通常就是生成目标文件。

每行命令之前必须有一个tab键。如果想用其他键，可以用内置变量.RECIPEPREFIX声明。

.RECIPEPREFIX = >
all:
> echo Hello, world

上面代码用.RECIPEPREFIX指定，大于号（>）替代tab键。所以，每一行命令的起首变成了大于号，而不是tab键。

需要注意的是，每行命令在一个单独的shell中执行。这些Shell之间没有继承关系。

var-lost:
    export foo=bar
    echo "foo=[$$foo]"

上面代码执行后（make var-lost），取不到foo的值。因为两行命令在两个不同的进程执行。一个解决办法是将两行命令写在一行，中间用分号分隔。

var-kept:
    export foo=bar; echo "foo=[$$foo]"

另一个解决办法是在换行符前加反斜杠转义。

var-kept:
    export foo=bar; \
    echo "foo=[$$foo]"

最后一个方法是加上.ONESHELL:命令。

.ONESHELL:
var-kept:
    export foo=bar; 
    echo "foo=[$$foo]"

三、Makefile文件的语法

3.1 注释

井号（#）在Makefile中表示注释。

# 这是注释
result.txt: source.txt
    # 这是注释
    cp source.txt result.txt # 这也是注释

3.2 回声（echoing）

正常情况下，make会打印每条命令，然后再执行，这就叫做回声（echoing）。

test:
    # 这是测试

执行上面的规则，会得到下面的结果。

$ make test
# 这是测试

在命令的前面加上@，就可以关闭回声。

test:
    @# 这是测试

现在再执行make test，就不会有任何输出。

由于在构建过程中，需要了解当前在执行哪条命令，所以通常只在注释和纯显示的echo命令前面加上@。

test:
    @# 这是测试
    @echo TODO

3.3 通配符

通配符（wildcard）用来指定一组符合条件的文件名。Makefile 的通配符与 Bash 一致，主要有星号（*）、问号（？）和 […] 等。

比如：

*.o ：表示所有后缀名为o的文件。
?：表示任意单个字符。
例如，abc?.txt匹配到的文件名是abca.txt、abcb.txt等。
[...]：表示括号中任意一个字符，可以使用短划线（-）表示范围。
例如，abc[de].txt匹配到的文件名可以是abc.txt或者abcde.txt，但不包括abcce.txt。
而abc[a-d].txt则匹配到abc.txt、abcb.txt、abcc.txt和abcd.txt。

clean:
        rm -f *.o

3.4 模式匹配

Make命令允许对文件名，进行类似正则运算的匹配，主要用到的匹配符是%。比如，假定当前目录下有 f1.c 和f2.c两个源码文件，需要将它们编译为对应的对象文件。

%.o: %.c

这是一个Makefile文件中的一个典型规则，它表示：

对于所有依赖目标名以“.o”结尾的目标，在当前目录或者其它指定搜索路径下，查找与之同名但后缀名为“.c”的源文件，并执行相应的命令，生成这个目标。

换句话说，这个规则用于描述如何将一个C语言源文件编译成一个目标文件。在这个规则中，“%.o”和“%.c”是通配符形式，它们将会自动匹配当前目录下相同前缀名称的.o和.c文件。例如，foo.o 依赖于 foo.c，那么这条规则就会被用来编译foo.c生成foo.o。这个规则可以被多个目标文件依赖并使用到，方便批量编译源代码。

等同于下面的写法。

f1.o: f1.c
f2.o: f2.c

使用匹配符%，可以将大量同类型的文件，只用一条规则就完成构建。

在Makefile中，%是一个通配符，表示任意匹配0个或多个字符的模式。它用于将规则（依赖关系）应用于一组相关的目标文件（例如，所有以“.o”结尾的目标文件），而不需要一个一个地列举它们。

具体来说，%通配符常常和特定的后缀名一起使用，如：

%.o: %.c

表示所有以.c结尾的源文件都可以被编译成对应的.o目标文件。在实际使用时，%会被自动替换成被匹配的目标名称的通配符部分，从而实现批量处理和编译。

这种技巧可以使 Makefile 更灵活和可维护，减少重复工作，提高代码重用率。

3.5 变量和赋值符

Makefile 允许使用等号自定义变量。

txt = Hello World
test:
    @echo $(txt)

上面代码中，变量 txt 等于 Hello World。调用时，变量需要放在 $( ) 之中。

当需要在 Makefile 中引用变量的值时，通常使用美元符号和括号或者花括号。

美元符号和括号：适用于大部分情况。可以用于引用任何已定义的变量，以及未定义的变量（在这种情况下将返回空值）。

  test:
  	@echo "Hello, $(NAME)!"

在这个规则中，$(NAME) 可以引用已经定义的变量 NAME 的值，也可以引用未定义的变量（在这种情况下将会输出空字符串）。

花括号：主要用于区分变量名和其他字符。花括号内的变量名称必须已经定义，否则会引发语法错误。
```
test:
	@echo "My name is ${FIRST_NAME}${LAST_NAME}"
```
在这个规则中，${FIRST_NAME} 和 ${LAST_NAME} 都必须是已经定义的变量名称。花括号可以使这两个变量的名称与紧随其后的}符号区分开来，从而避免了歧义和错误。

总之，美元符号和括号或者花括号都是用于引用 Makefile 中的变量，但在具体使用时，可能需要根据场景的不同做出选择。

如果需要区分变量和其他字符，建议使用花括号；如果不需要区分，则使用美元符号和括号即可。

调用Shell变量，需要在美元符号前，再加一个美元符号，这是因为Make命令会对美元符号转义。

test:
    @echo $$HOME

有时，变量的值可能指向另一个变量。

v1 = $(v2)

上面代码中，变量 v1 的值是另一个变量 v2。这时会产生一个问题，v1 的值到底在定义时扩展（静态扩展），还是在运行时扩展（动态扩展）？如果 v2 的值是动态的，这两种扩展方式的结果可能会差异很大。

为了解决类似问题，Makefile一共提供了四个赋值运算符（=、:=、？=、+=），它们的区别请看StackOverflow。

VARIABLE = value
# 在执行时扩展，允许递归扩展。

VARIABLE := value
# 在定义时扩展。

VARIABLE ?= value
# 只有在该变量为空时才设置值。

VARIABLE += value
# 将值追加到变量的尾端。

3.6 内置变量（Implicit Variables）

Make命令提供一系列内置变量，比如，$(CC) 指向当前使用的编译器，$(MAKE) 指向当前使用的Make工具。这主要是为了跨平台的兼容性，详细的内置变量清单见手册。

output:
    $(CC) -o output input.c

3.7 自动变量（Automatic Variables）

Make命令还提供一些自动变量，它们的值与当前规则有关。主要有以下几个。

1）$@

$@：指当前目标，就是Make命令当前构建的那个目标。
比如，make foo的 $@ 就指代foo。

a.txt b.txt: 
    touch $@

等同于下面的写法。

a.txt:
    touch a.txt
b.txt:
    touch b.txt

2）$<

$<：指代第一个前置条件。比如，规则为 t: p1 p2，那么$< 就指代p1。

a.txt: b.txt c.txt
    cp $< $@

等同于下面的写法。

a.txt: b.txt c.txt
    cp b.txt a.txt

3）$?

$? 指代比目标更新的所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，其中 p2 的时间戳比 t 新，$?就指代p2。

4）$^

$^ 指代所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，那么 $^ 就指代 p1 p2 。

5）$*

$* 指代匹配符 % 匹配的部分，比如% 匹配 f1.txt 中的f1 ，$* 就表示 f1。

6）$(@D) 和 $(@F)

$(@D) 和 $(@F) 分别指向 $@ 的目录名和文件名。比如，$@是 src/input.c，那么$(@D) 的值为 src ，$(@F) 的值为 input.c。

7）$(<D) 和 $(<F)

$(<D) 和 $(<F) 分别指向$< 的目录名和文件名。

所有的自动变量清单，请看手册。下面是自动变量的一个例子。

dest/%.txt: src/%.txt
    @[ -d dest ] || mkdir dest
    cp $< $@

dest/%.txt表示目标文件的路径格式，它由两部分组成：

dest/表示目标文件所在的目录，%.txt表示匹配任意.txt文件。因此，对于src/foo.txt文件，它的目标文件就是dest/foo.txt。
src/%.txt表示依赖文件的路径格式，它匹配与目标文件同名的.txt文件，并且它们都在src/目录下。
规则的主体是命令行，它以一个Tab键开头。
-d dest表示要测试的路径，其中-d选项用于测试一个路径是否是一个目录。如果dest/目录存在，则这个命令返回0；否则，返回非0值。
||是一个逻辑或运算符，当左侧命令返回非0值时，就会执行右侧的命令。
mkdir dest表示创建一个dest/目录。
然后，它使用cp命令将依赖文件$<（第一个前置条件）复制到$@（目标文件）中。$< 指代前置文件（src/%.txt），$@指代目标文件（dest/%.txt）。

举例二

$(<D)表示路径部分，表示$<所在的目录名。比如，如果$<为src/foo.txt，那么$(<D)就表示src/。
$(<F)表示文件名部分，表示$<中最后一个斜杠后面的字符串，也就是文件名部分。比如，如果$<为src/foo.txt，那么$(<F)就表示foo.txt。

这些变量通常用于构建过程中的命令行中，以方便地引用目标文件和依赖项的路径和名称。例如，下面是一个示例规则：

obj/%.o: src/%.c
    $(CC) -c $< -o $@ -I$(<D)

这是一个Makefile规则，用于将src/目录下的.c文件编译成.o目标文件，并将它们放到obj/目录中。具体来说，它的语法如下：

obj/%.o表示目标文件的路径格式，它由两部分组成：obj/表示目标文件所在的目录，%.o表示匹配任意以.o结尾的文件。因此，对于src/foo.c文件，它的目标文件就是obj/foo.o。
src/%.c表示依赖文件的路径格式，它匹配与目标文件同名的.c文件，并且它们都在src/目录下。
规则的主体是命令行，它以一个Tab键开头。在这个例子中，它首先使用$(CC)变量指定了gcc编译器，并使用-c选项告诉编译器只编译不链接。
然后，它使用$<变量引用第一个依赖文件（也就是源文件）的路径和名称。
-o表示指定输出文件名字(不然就是默认a.out) 。
$@表示目标文件的路径和名称。
-I$(<D)选项表示包含源代码所在的目录。

-I是一个编译器选项，用于指定头文件搜索路径。

具体来说，当我们编写一个C或C++程序时，通常需要包含一些标准库或自定义库的头文件。这些头文件通常位于某个特定的目录下，例如/usr/include或/usr/local/include等。为了让编译器正确地查找这些头文件，我们需要使用-I选项将它们添加到搜索路径中。

例如，假设我们有一个foo.c文件，它需要包含位于include/目录下的头文件bar.h，那么可以使用如下的编译命令：

gcc -c foo.c -o foo.o -Iinclude

在这个示例中，-Iinclude选项会将include/目录添加到头文件搜索路径中，使得编译器能够正确地查找并包含bar.h。

所以！！！！

当我们运行make命令时，它会检查所有的规则，并尝试构建那些需要更新的目标文件。在这个示例中，如果src/foo.c文件被修改，那么它的目标文件obj/foo.o就会被重新生成。

反之，如果目标文件已经是最新的，那么这个规则就不会被执行。通过使用Makefile，我们可以自动化地管理这些依赖关系，并且只需要更新必要的文件，从而提高效率并减少错误。

3.8 判断和循环

Makefile使用 Bash 语法，完成判断和循环。

ifeq ($(CC),gcc)
  libs=$(libs_for_gcc)
else
  libs=$(normal_libs)
endif

上面代码判断当前编译器是否 gcc ，然后指定不同的库文件。

LIST = one two three
all:
    for i in $(LIST); do \
        echo $$i; \
    done

# 等同于

all:
    for i in one two three; do \
        echo $i; \
    done

上面代码的运行结果。

one
two
three

3.9 函数

Makefile 还可以使用函数，格式如下。

$(function arguments)
# 或者
${function arguments}

Makefile提供了许多内置函数，可供调用。下面是几个常用的内置函数。

（1）shell 函数

shell 函数用来执行 shell 命令

srcfiles := $(shell echo src/{00..99}.txt)

（2）wildcard 函数

wildcard 函数用来在 Makefile 中，替换 Bash 的通配符。

srcfiles := $(wildcard src/*.txt)

（3）subst 函数

subst 函数用来文本替换，格式如下。

$(subst from,to,text)

下面的例子将字符串"feet on the street"替换成"fEEt on the strEEt"。

$(subst ee,EE,feet on the street)

下面是一个稍微复杂的例子。

comma:= ,
empty:=
# space变量用两个空变量作为标识符，当中是一个空格
space:= $(empty) $(empty)
foo:= a b c
bar:= $(subst $(space),$(comma),$(foo))
# bar is now `a,b,c'.

（4）patsubst函数

patsubst 函数用于模式匹配的替换，格式如下。

$(patsubst pattern,replacement,text)

下面的例子将文件名"x.c.c bar.c"，替换成"x.c.o bar.o"。

$(patsubst %.c,%.o,x.c.c bar.c)

（5）替换后缀名

替换后缀名函数的写法是：变量名 + 冒号 + 后缀名替换规则。它实际上patsubst函数的一种简写形式。

min: $(OUTPUT:.js=.min.js)

上面代码的意思是，将变量OUTPUT中的后缀名 .js 全部替换成 .min.js 。

四、Makefile 的实例

（1）执行多个目标

.PHONY: cleanall cleanobj cleandiff

cleanall : cleanobj cleandiff
        rm program

cleanobj :
        rm *.o

cleandiff :
        rm *.diff

上面代码可以调用不同目标，删除不同后缀名的文件，也可以调用一个目标（cleanall），删除所有指定类型的文件。

（2）编译C语言项目

edit : main.o kbd.o command.o display.o 
    cc -o edit main.o kbd.o command.o display.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
    cc -c display.c

clean :
     rm edit main.o kbd.o command.o display.o

.PHONY: edit clean

五、Makefile的特殊字符

在 Makefile 文件中，存在一些特殊字符，它们的含义不同于普通字符。下面列举了一些常见的特殊字符及其含义：

# 注释符号：用于在规则中添加注释，以提高可读性。
= 等号：用于定义变量，并将值赋给变量。
:= 冒号等于号：与等号类似，也用于定义变量。
不同之处在于，当变量被声明时，其值会立即求解并保存。
这意味着变量的值在 Makefile 的执行过程中只计算一次。
+= 加等号：用于向现有变量添加内容而不是覆盖它的值。
此操作相当于将旧值和新值连接成一个字符串。
?= 问号等于号：类似于等号和冒号等于号，也用于定义变量。
与两者不同的是，如果变量已经被定义，则该操作不会覆盖它的值。
$ 特殊字符：用于引用变量。可以使用 $(…) 或 ${…} 表示变量的值，也可以使用$$表示一个普通的$字符。
@ 特殊符号：在命令行前加上@符号可以阻止其被显示出来。这在运行一些特别长或者复杂的命令时非常有用。
- 特殊符号：可以将命令的返回结果忽略，并继续执行 Makefile 中的其他规则。
% 特殊字符：用于表示模式匹配，在规则中可以使用 % 来通配符代替文件名中的一部分。
例如，%.c 表示任意以 .c 结尾的文件名。
| 管道符号：用于定义目标的依赖关系，并指定要在所有依赖项都更新后才运行的命令。与普通的依赖关系不同，使用管道符号定义的依赖项不会被视为Makefile 中的真正目标。
:: 特殊符号：如果两个冒号（::）出现在规则的目标后面，则表示该规则具有“双冒号”语义。这种语义下，执行命令时不会涉及到时间戳和依赖项的判断，而只会执行规则中的命令。这种类型的规则被称为 “标签语句”（label statement），通常用于在 Makefile 文件中添加注释或执行一些额外的操作。
· 特殊字符：和 % 类似，用于表示通配符，可以匹配任意长度的字符串。用法类似于 Shell 中的通配符，例如 *.c 表示以 .c 结尾的任意文件名。
[] 特殊字符：用于表示字符集匹配，可以指定匹配一组字符中的任意一个。例如，[abcd].c 表示 a.c、b.c、c.c 或 d.c 这几个文件中的任意一个。
^ 特殊字符：用于否定整个字符集，表示不匹配其中的任何一个字符。例如，[^abc].c 表示不匹配所有以 a、b、c 中任意一个字符开头，并以 .c 结尾的文件名。
() 特殊符号：用于分组，在规则中限定一个或多个表达式的作用范围。这对于在匹配模式时使用多个通配符非常有用，可以确保正确匹配所需的部分。