参考链接：

跟我一起写 Makefile — 跟我一起写 Makefile 1.0 文档

Makefile 简明教程 - FanZheng's blog

https://hacker-yhj.github.io/resources/gun_make.pdf

在使用 gcc 编译器开发的时候，会用到 Makefile，那么，就来记录一下 Makefile 的学习。

首先呢，先说明一下观看顺序，咳咳，其实就是自己学的时候后面发现这样学更有趣味。

正式入主题：

1. 先大致看一下上面链接一的内容，先不用深记，只需大概知道有哪些内容，对应在哪个位置就行了，因为后面还要返回去，毕竟大神写的文章细味斟酌，回头品尝又是一番滋味；
2. 链接二的内容可谓是初学者福利啊（至少对于我来说是这样），作者挑了一些常用的内容列举出来，话不多说，结合例子容易理解，然后可以每学一个内容可以回去翻看链接一大神写的内容，相互结合更好学习
3. 链接三是另一个大佬整理出来的 GNU make 中文手册
4. 最后，下文是本人觉得有要用到的一些知识的整理

# 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 文件是大写字母开头的 Makefile，使用者使用的是小写的 makefile（默认的情况下，make 命令会在当前目录下按顺序找寻文件名为 “ GNUmakefile ” 、 “ makefile ” 、 “ Makefile ” 的文件，找到了就解析这个文件。在这三个文件名中，最好使用 “Makefile” 这个文件名，因为，这个文件名第一个字符为大写，这样有一种显目的感觉。最好不要用 “ GNUmakefile ” ，这个文件是 GNU 的 make 识别的。有另外一些 make 只对全小写的 “ makefile ” 文件名敏感，但是基本上来说，大多数的 make 都支持 “ makefile ” 和 “ Makefile ” 这两种默认文件名。我们也可以使用 make –f filename 指定所要解释的 Makefile 的文件名）

# make 的工作方式

- 1. 读入主 Makefile (主 Makefile 中可以引用其他 Makefile)

- 2. 读入被 include 的其他 Makefile

- 3. 初始化文件中的变量

- 4. 推导隐晦规则，并分析所有规则

- 5. 为所有的目标文件创建依赖关系链

- 6. 根据依赖关系，决定哪些目标要重新生成

- 7. 执行生成命令

# Makefile 的规则

target ... : prerequisites ...

<tab> command

       ...

       ...

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

Target（目标）

可以是一个 object file（目标文件），也可以是一个执行文件，还可以是一个标签（label），指明 make 命令所要构建的对象。目标（target）后面必须有冒号 :

Prerequisites（前置条件）

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

Command（命令）

该 target 要执行的命令（任意的 Shell 命令）。表示如何更新目标文件，有一行或多行的 Shell 命令组成。它是构建 “目标” 的具体命令，他是运行结果通常就是生成目标文件。每行命令行必须以 tap 键作为开头

注意：

• 必须讲明， Makefile 的命令是要调用 shell 来运行的 ，而到底是使用的哪个 shell 取决于 Makefile 中 SHELL 变量的设置，默认为 /bin/sh 就是 bash。
• 在 Makefile 中使用 bash 的变量。 Makefile 中使用 $() 引用的是 Makefile 内的变量，如果想使用 bash 环境的变量要使用双美元引用 $$ ，使用单个 $ 引用的变量全部被解释为 Makefile 的变量。以此类推，如果要想试图用 bash 中的进程号码就要使用四个 $ ，即： $$$$ 。
• 另外，值得强调的一点是： Makefile 是一次发送一行命令，每发送一次命令，就会启动一个 subshell 来运行。这意味着命令之间不能共享变量，而且 bash 中可以使用的 for 和 while，在这里面也不能换行，因为每行会被单独的发送给 bash 来执行。要解决这个问题，要么使用 Makefile 中的换行符 \ ，要么写成单行的形式。
• 在命令行之间中的空格或是空行会被忽略，但是如果该空格或空行是以 Tab 键开头的，那么 make 会认为其是一个空命令。

# # 注释符

# 字符是注释符，Makefile 把 # 字符后面的内容作为注释内容处理（shell、perl 脚本也是使用 # 字符作为注释符）。如果某行的第一个非空字符为 # ，则此行会被 make 解释为注释行（命令行除外，如果 Tab 字符之后使用 # 字符，则会被 make 解释为命令行）。

注释行的结尾如果存在反斜线 \ ，那么下一行也被作为注释行。

如果需要注视多行，在注释行的结尾加行反斜线 (), 下一行也被注释，可以注释多行。

建议在书写 Makefile 时将注释作为一个独立的行，而不要和 Makefile 的有效行放在同一行中书写。make 有时候会把 # 字符之前的内容作为有效行的内容（如定义变量的时候）。

当在 Makefile 中需要使用字符 # 时，可以使用 \ 加 # （ \# ）来实现，表示将 # 字符作为一个普通字符而不是注释符。

# GCC 常用参数

-c： 只编译不链接，仅生成目标文件

-o： 指定输出文件名

**-l： ** 手动添加链接库

**-E： ** 生成预处理文件

**-S： ** 生成汇编文件

-I： 将系统缺省的头文件路径扩展到当前路径

-O2： 表示我们希望编译器在编译的时候对我们的程序进行一定程度的优化。2 表示我们优化的级别是 2。范围是 1-3（O/ O2/ O3）。不过习惯上我们都使用 2 的优化级别

-g： 生成调试信息

-Wall： 显示警告信息

# 基础变量

• = 递归展开：变量只在引用时才确定它的值，因此这句话在 Makefile 中的任何位置都没有区别，即使它引用了其他变量，除非对自身多次赋值。需要注意避免循环定义
• := 直接展开：变量的值在写这句话时就已经确定。若它引用了其他变量，则直接用那个变量当前的值，而不管该变量在此之后值如何变化
• ?= 条件赋值：只有此变量在之前没有赋值的情况下才会对这个变量进行赋值，它是递归展开的
• += 追加赋值：给变量追加内容，但会在追加内容之前添加一个空格。它是直接展开还是递归展开取决于该变量上一次赋值的方式

# 自动变量（Automatic Variables）

• $@ ：表示规则中的目标文件集。在模式规则中，如果有多个目标，那么， $@ 就是匹配于目标中模式定义的集合。
• $% ：仅当目标是函数库文件中，表示规则中的目标成员名。例如，如果一个目标是 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 所不能识别的，那么 $* 就是空值。

# 隐晦规则

# 关于命令的变量

• 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

# 关于命令参数的变量

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

• 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 文法分析器参数。

# Make 自动推导

foo.o: foo.c foo.h       # foo 模块

gcc -c foo.c

bar.o: bar.c bar.h 

gcc -c bar.c 

main: main.c foo.h bar.h foo.o bar.o 

gcc main.c -o main foo.o bar.o

该例子的场景是：我们要通过 main.c 编译一个叫做 main 的程序，它需要使用 foo.c 和 bar.c 里的函数，同时需要引入相关头文件里的声明。该任务通过 make main 来执行。

foo.o 是我们的目标， foo.c 和 foo.h 是目标所依赖的源文件，而只有一个命令 gcc -c foo.c （以 Tab 键开头）； bar.o 这个目标同理。这个规则告诉我们两件事：

1. 文件的依赖关系， foo.o 依赖于 foo.c 和 foo.h 的文件，如果 foo.c 和 foo.h 的文件日期要比 foo.o 文件日期要新，或是 foo.o 不存在，那么依赖关系发生。
2. 生成或更新 foo.o 文件，就是那个 gcc 命令。它说明了如何生成 foo.o 这个文件。 （当然， foo.c 文件 include 了 foo.h 文件）

而 main 的 “依赖” 中有 foo.o 和 bar.o ，它们两个必须先被构建。当我们执行 make main 时，由于 foo.o 和 bar.o 并不存在， make 程序就会在 Makefile 中寻找这两个 “目标” 的构建方法，构建完成后再进行 main 的构建。

再看一下下面的例子，执行的结果同样跟上面的例子一样

foo.o: foo.h 

bar.o: bar.h 

main: main.c foo.h bar.h foo.o bar.o 

gcc main.c -o main foo.o bar.o

通过对比发现， .o 文件所依赖的 .c 文件省略掉了，同时也把命令省略了，这是为什么呢？

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

只要 make 看到一个 .o 文件，它就会自动的把 .c 文件加在依赖关系中，如果 make 找到一个 bar.o ，那么 bar.c 就会是 bar.o 的依赖文件。并且 gcc -c bar.c 也会被推导出来，于是，我们的 Makefile 再也不用写得这么复杂；这样就得到了上面第二个例子。这种方法，也就是 make 的 “隐晦规则” 。

但在日常使用中，我们为什么要像 foo.o: foo.c foo.h 一样将必然存在的文件设置成 “依赖” 呢？因为 make 存在这样一种机制，如果 “目标” 中的某个 “依赖项” 的修改时间晚于上次 make 该 “目标” 的时间，就说明该 “目标” 过时了，需要重新构建。如果你不把影响该 “目标” 的所有必要的 “依赖” 都写上，那当你修改某个文件后，make 就会因为 “目标” 已存在而不再构建。

因此， foo.c/foo.h 或 bar.c/bar.h 的修改会导致 foo.o 或 bar.o 过时而重新构建，从而使得 main 也必须重新构建。

# Makefile 的伪目标（.PHONY）

(1) 伪目标意思是这个目标本身不代表一个文件，执行这个目标不是为了得到某个文件或东西，而是单纯为了执行这个目标下面的命令。

(2) 伪目标一般都没有依赖，因为执行伪目标就是为了执行目标下面的命令。既然一定要执行命令了那就不必加依赖，因为不加依赖意思就是无条件执行。

(3) 伪目标可以直接写，不影响使用；但是有时候为了明确声明这个目标是伪目标会在伪目标的前面用 .PHONY 来明确声明它是伪目标。

典型的伪目标是 Makefile 中用来清理编译过程中中间文件的 clean 伪目标，一般格式如下:

.PHONY: clean   # 这句没有也行，但是最好加上

clean:

    -rm -f *.o

下面列举一些常用的伪目标，如果在自己项目的 Makefile 合理使用这些伪目标的话，可以让我们自己的 Makefile 看起来更专业

# 条件语句

<conditional-directive>

<text-if-true>

else

<text-if-false>

endif

其中 <conditional-directive> 表示条件关键字，这个关键字有四个。条件语句的目的是通过判断来决定 Makefile 中的相应位置应该有什么内容

• 第一个条件关键字是 ifeq 。语法是：

ifeq (<arg1>, <arg2>)

ifeq '<arg1>' '<arg2>'

ifeq "<arg1>" "<arg2>"

ifeq "<arg1>" '<arg2>'

ifeq '<arg1>' "<arg2>"

比较参数 arg1 和 arg2 的值是否相同，相同为真。

• 第二个条件关键字是 ifneq 。语法是：

ifneq (<arg1>, <arg2>)

ifneq '<arg1>' '<arg2>'

ifneq "<arg1>" "<arg2>"

ifneq "<arg1>" '<arg2>'

ifneq '<arg1>' "<arg2>"

其比较参数 arg1 和 arg2 的值是否相同，如果不同，则为真；和 ifeq 类似。

• 第三个条件关键字是 ifdef 。语法是：

ifdef <variable-name>

如果变量 <variable-name> 的值非空，那到表达式为真。否则，表达式为假。当然， <variable-name> 同样可以是一个函数的返回值。注意， ifdef 只是测试一个变量 是否有值，其并不会把变量扩展到当前位置。

• 第四个条件关键字是 ifndef 。其语法是：

ifndef <variable-name>

如果变量 <variable-name> 的值空，那到表达式为真。否则，表达式为假。，和 ifdef 是相反的意思。

# 字符串处理函数

# subst

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

• 名称：字符串替换函数
• 功能：把字串 <text> 中的 <from> 字符串替换成 <to> 。
• 返回：函数返回被替换过后的字符串。
• 示例：

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

把 feet on the street 中的 ee 替换成 EE ，返回结果是 fEEt on the strEEt 。

# patsubst

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

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

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

把字串 x.c.c bar.c 符合模式 %.c 的单词替换成 %.o ，返回结果是 x.c.o bar.o

• 备注：这和我们前面 “变量章节” 说过的相关知识有点相似。如 $(var:<pattern>=<replacement>;) 相当于 $(patsubst <pattern>,<replacement>,$(var)) ，而 $(var: <suffix>=<replacement>) 则相当于 $(patsubst %<suffix>,%<replacement>,$(var)) 。

例如有:

objects = foo.o bar.o baz.o，

那么， $(objects:.o=.c) 和 ​ $(patsubst %.o,%.c,$(objects)) 是一样的。

# strip

$(strip <string>)

• 名称：去空格函数。
• 功能：去掉 <string> 字串中开头和结尾的空字符。
• 返回：返回被去掉空格的字符串值。
• 示例：

$(strip a b c )

把字串 a b c<空格> 去掉开头和结尾的空格，结果是 a b c 。

# findstring

$(findstring <find>,<in>)

• 名称：查找字符串函数
• 功能：在字串 <in> 中查找 <find> 字串。
• 返回：如果找到，那么返回 <find> ，否则返回空字符串。
• 示例：

$(findstring a,a b c)

$(findstring a,b c)

第一个函数返回 a 字符串，第二个返回空字符串

# filter

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

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

sources := foo.c bar.c baz.s ugh.h

foo: $(sources)

    cc $(filter %.c %.s,$(sources)) -o foo

$(filter %.c %.s,$(sources)) 返回的值是 foo.c bar.c baz.s 。

# filter-out

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

• 名称：反过滤函数
• 功能：以 <pattern> 模式过滤 <text> 字符串中的单词，去除符合模式 <pattern> 的单词。可以有多个模式。
• 返回：返回不符合模式 <pattern> 的字串。
• 示例：

objects=main1.o foo.o main2.o bar.o

mains=main1.o main2.o

$(filter-out $(mains),$(objects)) 返回值是 foo.o bar.o 。

# sort

$(sort <list>)

• 名称：排序函数
• 功能：给字符串 <list> 中的单词排序（升序）。
• 返回：返回排序后的字符串。
• 示例： $(sort foo bar lose) 返回 bar foo lose 。
• 备注： sort 函数会去掉 <list> 中相同的单词。

# word

$(word <n>,<text>)

• 名称：取单词函数
• 功能：取字符串 <text> 中第 <n> 个单词。（从一开始）
• 返回：返回字符串 <text> 中第 <n> 个单词。如果 <n> 比 <text> 中的 单词数要大，那么返回空字符串。
• 示例： $(word 2,foo bar baz) 返回值是 bar 。

# wordlist

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

• 名称：取单词串函数
• 功能：从字符串 <text> 中取从 <ss> 开始到 <e> 的单词串。 <ss> 和 <e> 是一个数字。
• 返回：返回字符串 <text> 中从 <ss> 到 <e> 的单词字串。如果 <ss> 比 <text> 中的单词数要大，那么返回空字符串。如果 <e> 大于 <text> 的单词数， 那么返回从 <ss> 开始，到 <text> 结束的单词串。
• 示例： $(wordlist 2,3,foo bar baz) 返回值是 bar baz 。

# words

$(words <text>)

• 名称：单词个数统计函数
• 功能：统计 <text> 中字符串中的单词个数。
• 返回：返回 <text> 中的单词数。
• 示例： $(words foo bar baz) 返回值是 3 。
• 备注：如果我们要取 <text> 中最后的一个单词，我们可以这样： $(word $(words <text>),<text>) 。

# firstword

$(firstword <text>)

• 名称：首单词函数 ——firstword。
• 功能：取字符串 <text> 中的第一个单词。
• 返回：返回字符串 <text> 的第一个单词。
• 示例： $(firstword foo bar) 返回值是 foo 。
• 备注：这个函数可以用 word 函数来实现： $(word 1,<text>) 。

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

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

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

# 文件名操作函数

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

# dir

$(dir <names...>)

• 名称：取目录函数 —— dir。
• 功能：从文件名序列 <names> 中取出目录部分。目录部分是指最后一个反斜杠 / 之前 的部分。如果没有反斜杠，那么返回 ./ 。
• 返回：返回文件名序列 <names> 的目录部分。
• 示例： $(dir src/foo.c hacks) 返回值是 src/ ./ 。

# notdir

$(notdir <names...>)

• 名称：取文件函数 —— notdir。
• 功能：从文件名序列 <names> 中取出非目录部分。非目录部分是指最後一个反斜杠 / 之后的部分。
• 返回：返回文件名序列 <names> 的非目录部分。
• 示例： $(notdir src/foo.c hacks) 返回值是 foo.c hacks 。

# suffix

$(suffix <names...>)

• 名称：取後缀函数 —— suffix。
• 功能：从文件名序列 <names> 中取出各个文件名的后缀。
• 返回：返回文件名序列 <names> 的后缀序列，如果文件没有后缀，则返回空字串。
• 示例： $(suffix src/foo.c src-1.0/bar.c hacks) 返回值是 .c .c 。

# basename

$(basename <names...>)

• 名称：取前缀函数 —— basename。
• 功能：从文件名序列 <names> 中取出各个文件名的前缀部分。
• 返回：返回文件名序列 <names> 的前缀序列，如果文件没有前缀，则返回空字串。
• 示例： $(basename src/foo.c src-1.0/bar.c hacks) 返回值是 src/foo src-1.0/bar hacks 。

# addsuffix

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

• 名称：加后缀函数 —— addsuffix。
• 功能：把后缀 <suffix> 加到 <names> 中的每个单词后面。
• 返回：返回加过后缀的文件名序列。
• 示例： $(addsuffix .c,foo bar) 返回值是 foo.c bar.c 。

# addprefix

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

• 名称：加前缀函数 —— addprefix。
• 功能：把前缀 <prefix> 加到 <names> 中的每个单词后面。
• 返回：返回加过前缀的文件名序列。
• 示例： $(addprefix src/,foo bar) 返回值是 src/foo src/bar 。

# join

$(join <list1>,<list2>)

• 名称：连接函数 —— join。
• 功能：把 <list2> 中的单词对应地加到 <list1> 的单词后面。如果 <list1> 的单词个数要比 <list2> 的多，那么， <list1> 中的多出来的单词将保持原样。如果 <list2> 的单词个数要比 <list1> 多，那么， <list2> 多出来的单词将被复制到 <list1> 中。
• 返回：返回连接过后的字符串。
• 示例： $(join aaa bbb,111 222 333) 返回值是 aaa111 bbb222 333 。

# foreach 函数

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

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

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

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

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 中的 <var> 参数是一个临时的局部变量，foreach 函数执行完后，参数 <var> 的变量将不在作用，其作用域只在 foreach 函数当中。

# if 函数

if 函数很像 GNU 的 make 所支持的条件语句 —— ifeq（参见前面所述的章节），if 函数的语法是：

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

或是

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

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

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

所以， <then-part> 和 <else-part> 只会有一个被计算。

# call 函数

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

$(call <expression>,<parm1>,<parm2>,...,<parmn>)

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

reverse =  $(1) $(2)

foo = $(call reverse,a,b)

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

reverse =  $(2) $(1)

foo = $(call reverse,a,b)

此时的 foo 的值就是 b a 。

需要注意：在向 call 函数传递参数时要尤其注意空格的使用。call 函数在处理参数时，第 2 个及其之后的 参数中的空格会被保留，因而可能造成一些奇怪的效果。因而在向 call 函数提供参数时，最安全的做法是去除所有多余的空格。